{"cells":[{"cell_type":"markdown","metadata":{"id":"22B733A3BFE049CCA72BE2F628394282","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","runtime":{"execution_status":null,"is_visible":false,"status":"default"},"scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[]},"source":[" # <center>  Lecture 6 : MCMC </center>  \n"," \n","##  <center>  Instructor: Dr. Hu Chuan-Peng   </center>  \n"]},{"cell_type":"markdown","metadata":{},"source":["在上一节课中，通过简单的 Beta-Binomial 模型中，我们已经看到 PyMC 可以帮助我们得到后验分布。\n","\n","且这个过程中使用了**MCMC算法** 从后验分布中进行抽样。\n","\n","为什么 **MCMC算法** 可以得到后验分布的样本？🤔  \n","\n","为了更深入理解这些方法，我们现在回到基础，从第一个MC(Monte Carlo)方法开始。😎  "]},{"cell_type":"markdown","metadata":{},"source":["## Monte Carlo, Markov Chain 和 Markov Chain Monte Carlo\n","\n","### 什么是 Monte Carlo\n","\n","- Monte Carlo 方法是一种通过**随机采样**模拟复杂现象的数值计算方法。\n","\n","假设我们知道这个正方形的面积，想估算图中圆形的面积（但不使用圆的面积的公式），通过何种近似的方法可以怎么解决这一问题呢？\n","\n","<center>  \n","    <table>  \n","            <tr>  \n","                <td><img src=\"https://cdn.kesci.com/upload/slozv1v2pv.png?imageView2/0/w/480/h/960\" alt=\"\"></td>  \n","                <td><img src=\"https://cdn.kesci.com/upload/slozv7t6h6.png?imageView2/0/w/480/h/960\" alt=\"\"></td>  \n","            </tr>  \n","            <tr>  \n","                <td></td>  \n","                <td></td>  \n","            </tr>  \n","    </table>  \n","</center>  \n","\n","1. **随机投点**：我们在一个边长为 10 英寸 的正方形区域内随机放置 20 个点。\n","2. **计算圆内的点数比例**：统计这些点中有多少落在圆内，并计算这一比例。\n","3. **面积估算**：根据比例，乘以正方形的面积（100 平方英寸），即可得到近似的圆面积。\n","\n","**Monte Carlo 的核心思想**：\n","  1. **随机抽样**：通过从某个已知的概率分布中随机抽样，估计该分布的期望或其他统计量。\n","  2. **近似逼近**：随着样本数量增加，抽样结果会逐渐逼近真实分布的统计特性。"]},{"cell_type":"markdown","metadata":{},"source":["#### Normal-Normal 模型的后验分布  \n","\n","首先，是我们正态模型为例子（贝叶斯中，我们使用 Normal-Normal表示先验与似然都是Normal Dist）。  \n","\n","假设我们知道一个正态分布的标准差为0.75的正态分布，但是其平均值$\\mu$是未知的，我们想通过从这个正态分布中取一个数据来估计这个正态分布的平均值$\\mu$的范围。\n","\n","1. **似然模型**：假设我们从一个平均值为$\\mu$，标准差为0.75的正态分布中获取了一个$Y=6.25$的数据：  \n","    $$  \n","    Y|\\mu  \\sim \\ N(\\mu, 0.75^2)  \n","    $$  \n","\n","2. **先验模型**：假定这个正态分布的均值是可能是从如下正态分布中取值的：  \n","    $$  \n","    \\mu  \\sim \\ N(0, 1^2)  \n","    $$  \n","\n","    *可以简单理解成我们一开始对$\\mu$的信念，为$\\mu$在平均值为0，标准差为1的正态分布中波动*  \n","\n","3. **后验分布**：那么在$Y=6.25$这个结果下，结合先验，更新后的$\\mu$是怎样的？  \n","\n","    $$\\mu | (Y = 6.25) \\sim \\text{N}(?,?)$$  \n","\n","**后验分布解析解：**  \n","\n","在lec5中，我们知道Normal-Normal为共轭先验，则后验分布存在可进行直接的计算：\n","\n","$$  \n","\\mu|\\vec{y} \\sim N\\left(\\frac{\\theta\\sigma^2 + \\bar{y}n\\tau^2}{n\\tau^2 + \\sigma^2}, \\frac{\\tau^2\\sigma^2}{n\\tau^2 + \\sigma^2}\\right)  \n","$$  \n","\n","其中：  \n","- $\\bar{y}$ 是样本的均值（观测到的平均正确率），  \n","- $\\sigma^2$ 是已知的正确率方差，  \n","- $\\tau^2$ 是先验的方差。  \n","\n","- **后验均值**：后验均值是先验均值 $\\theta$ 和样本均值 $\\bar{y}$ 的加权平均：  \n","\n","  $$  \n","  \\text{posterior mean} = \\frac{0 \\times 0.75^2 + 6.25 \\times 1^2}{1^2 + 0.75^2} = \\frac{6.25}{1.5625} = 4  \n","  $$  \n","\n","- **后验方差**：后验方差受先验的方差 $\\tau^2$ 和样本数据的方差 $\\sigma^2$ 的共同影响：  \n","\n","  $$  \n","  \\text{posterior variance} = \\frac{1^2 \\times 0.75^2}{1^2 + 0.75^2} = \\frac{0.5625}{1.5625} = 0.6^2 \n","  $$  \n"," \n","> 因此，我们得到更新后的$\\mu$的分布为：\n","> $$\\mu | (Y = 6.25) \\sim \\text{N}(4, 0.6^2)$$  \n"]},{"cell_type":"markdown","metadata":{},"source":["**后验分布模型 vs. 从后验分布采样**  \n","\n","📍需要明确的一点：通过解析计算得到的后验分布模型与从基于后验分布的采样结果并不完全相同。 \n","\n","在上述例子中，我们通过解析计算得到了后验分布的具体形式（模型）：\n","> $$\\mu | (Y = 6.25) \\sim \\text{N}(4, 0.6^2)$$  \n","\n","这并不意味着我们可以直接从表达式中获得参数的**样本**。为了生成这些样本，我们需要通过Monte Carlo过程采样。\n","\n","简单地说：我们希望得到的样本的数量与每个样本在分布模型中的可能性之间是成比例的，某个值出现的概率越大，在采样中，它出现的次数应该越多。\n","\n","反过来：如果我们能从某个分布中采到足够多的样本，那么我们也可以通过对这些样本的统计量进行计算，来估计这个分布本身的模型参数。"]},{"cell_type":"markdown","metadata":{},"source":["在现代的概率编辑语言中，我们很容易能够进行Monte Carlo采样。\n","\n","比如，对于上述的正态分布 $N(4, 0.6^2)$，我们可以通过如下代码进行Monte Carlo采样并进行可视化："]},{"cell_type":"code","execution_count":1,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["前 10 个样本值： [7.82106053 5.84653561 5.51158156 6.38897953 7.6325137  5.08262722\n"," 6.76971937 7.50396243 7.28796121 5.31063869]\n"]}],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","from scipy.stats import norm\n","\n","x_range = np.linspace(2, 10, 1000)       # 设置 x 的范围为 [2,10] \n","y_norm = norm.pdf(x_range, 6.25, 0.75)\n","\n","# 对y_norm进行采样，得到1000个样本值\n","samples = np.random.normal(6.25, 0.75, 1000)\n","\n","# 显示前 10 个样本值\n","first_10_samples = samples[:10]\n","print(\"前 10 个样本值：\", first_10_samples)"]},{"cell_type":"code","execution_count":2,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1000x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["#  绘制图像\n","plt.figure(figsize=(10, 6))\n","plt.plot(x_range, norm.pdf(x_range, 6.25, 0.75), linewidth=2, color='r', label='Normal Distribution PDF')\n","count, bins, ignored = plt.hist(samples, bins=30, density=True, alpha=0.6, color='grey', edgecolor='black', label='Sampled Histogram')\n","\n","plt.legend()\n","plt.show()"]},{"cell_type":"markdown","metadata":{},"source":["**未归一化的后验分布(unnormalized posterior pdf)**  \n","\n","我们在上节课讲到，在现实的数据分布中，往往模型比较复杂，导致我们进行的计算变得复杂，尤其是分母部分的归一化因子，\n","\n","❓为什么归一化因子比较难以计算？  \n"]},{"cell_type":"markdown","metadata":{},"source":["假如归一化因子（分母）比较难以计算，是不是可以不计算？\n","\n","<center>  \n","    <table>  \n","            <tr>  \n","                <td><img src=\"https://cdn.kesci.com/upload/slozv1v2pv.png?imageView2/0/w/480/h/960\" alt=\"\"></td>  \n","                <td><img src=\"https://cdn.kesci.com/upload/slozv7t6h6.png?imageView2/0/w/480/h/960\" alt=\"\"></td>  \n","            </tr>  \n","            <tr>  \n","                <td></td>  \n","                <td></td>  \n","            </tr>  \n","    </table>  \n","</center>  \n","\n","Q: 假如我们只知道上面随机点的信息，但不知道正方形的面积，我们如何估算圆的面积？\n","A: 使用足够多的点，计算圆内点的比例"]},{"cell_type":"markdown","metadata":{},"source":["对于贝叶斯推断来说，我们可能可以不用计算归一化因子，直接通过对后验分布的采样来近似得到后验分布。\n","\n","$$f(\\mu | y=6.25) \\propto f(\\mu)L(\\mu|y=6.25).$$  \n","\n","- 尽管未归一化的分布并不是真正的后验分布，但这二者的形状、集中趋势、变异性是一样的  \n","- 可以看到，真实的后验分布和未归一化后验分布，处理在 y 轴上的单位不一样，但他们的形状、集中趋势、变异性是一样的  \n","- 重要的是，两个分布中，$\\mu$ 的结果主要集中在 2-6 之间  \n","\n","因此，当进行采样时，我们可以使用**未归一化的后验分布** 的结果来替代计算真实的后验分布 $f(\\mu)$  \n","\n","![Image Name](https://cdn.kesci.com/upload/s2ty9jty8t.png?imageView2/0/w/960/h/960)  \n","\n","\n","那么新的问题是，如何在不计算复杂归一化常数的情况下，有效地生成样本？🤔\n"]},{"cell_type":"markdown","metadata":{},"source":["### Markov Chain Monte Carlo\n","\n","Markov Chain（马尔可夫链）即可自然地解决了未归一化的后验分布的问题。\n","\n","原因：\n","- 每次只关注当前的状态。\n","- 利用当前状态生成建议分布（proposed distribution）。\n","- 判断是否接受新的状态，构建一个链条来近似后验分布。\n","\n","我们以一个心情变化的例子来深入理解 Markov Chain：\n","\n","- 假如不同的情绪对应一种状态，也就是参数可能的取值。\n","- 那么，我们可以将不同的心情（如“冷静”、“悲伤”、“开心”）定义为 状态。这些状态中的每一个代表参数 $\\theta_k$ 的不同取值：\n","  - 例如，冷静是 $\\theta_1=0.5$; 悲伤是 $\\theta_2=0.3$；开心是$\\theta_3=0.7$； 以此类推.....。  \n","  - 这样，我们可以确定参数选择的范围 $\\theta_{k} \\sim [0,1]$，参数是离散变量，每一个值对应一种心情。  \n","  - 注意，我们用下标 k 来表示不同的心情以及对应的参数值。  \n","\n","<table>  \n","    <tr>  \n","        <td><img src=\"https://cdn.kesci.com/upload/s2vta0gekr.png?imageView2/0/w/500/h/500\" alt=\"图片1\" width = 600></td>  \n","    </tr>  \n","</table>  \n","\n","- 状态转移：每一天我们的心情都会发生变化或者不变，代表一次采样，即一次状态的转移。 \n","   - 长时间跟踪这些状态，我们会得到一个 马尔可夫链:$\\left\\lbrace \\theta^{(1)}, \\theta^{(2)}, \\ldots, \\theta^{(N)} \\right\\rbrace$,这里 $n$ 表示天数，$\\theta^{(n)}$ 是第 $n$ 天的具体心情。\n","\n","- **“无记忆性”**：无记忆性是马尔可夫链的关键特点,今天的心情（当前状态）只依赖于昨天的心情（前一状态），例如：\n","   - 如果前一天是“开心” $\\theta_3$，那么今天仍然保持“开心”的概率是 0.5，\n","   - 变为“冷静”的概率是 0.25，变为“悲伤”的概率也是 0.25。\n","\n","\n","我们可以根据上面的概率构建一个状态转移表，用于描述从一个状态跳转到另一个状态的可能性：\n","\n","| 心情 | 开心$\\theta^{(n-1)}_{1}$ | 冷静$\\theta^{(n-1)}_{2}$ | 悲伤$\\theta^{(n-1)}_{3}$ | ... |  \n","| :----: | :----: | :----: | :----: | :----: |  \n","| 开心$\\theta^{(n)}_{1}$ | 0.5 | 0.25 | 0.25 | ... |  \n","| 冷静$\\theta^{(n)}_{2}$ | 0.5 | 0 | 0.5 | ... |  \n","| 悲伤$\\theta^{(n)}_{3}$ | 0.25 | 0.25 | 0.5 | ... |  \n","| ... | ... | ... | ... | ... |  \n","\n","解释：\n","- 每一行代表当前状态影响下一状态的概率，也就是 当日心情(n)受到上一天心情(n-1)的影响。  \n","- 可以写成服从概率分布的形式：$choice(n) \\sim Distribution(n-1)$。  \n","- 这里的 **Distribution 就是建议分布**。  \n","  - 它为第二天的心情变化提供了建议，所以被称为建议分布 $q(x)$，并且根据这个分布来选择是否接受新的状态。\n","  \n","马尔可夫链的的好处：当我们运行一段时间后，会发现慢慢会稳定在某个状态，高概率的更多出现，低概率的情况更少出现。\n"]},{"cell_type":"markdown","metadata":{},"source":["### 为什么 Monte Carlo 需要加上 Markov Chain？\n","\n","原因：\n","1. Monte Carlo 方法通过从目标分布中直接采样，使用大量随机样本来逼近期望值或目标概率。这种方法在低维分布中工作良好，但在高维复杂分布中直接采样变得非常困难和不现实。\n","\n","2. 为了解决高维空间中的采样困难，MCMC 使用马尔可夫链生成样本。每次样本的生成只依赖于前一次的状态，因此构建了一个可以逐渐收敛于目标分布的链条。\n","\n","所以，MCMC 的核心思想即：\n","- **构建一个符合目标分布的马尔可夫链**：\n","每次新样本的生成依赖于前一个状态，逐步逼近目标分布。\n","- **长时间采样达到平稳分布**：\n","当马尔可夫链达到稳态分布时，采样结果便可以作为目标分布的近似。\n","\n","尽管 MCMC 的实现方式多种多样，但所有方法的目标都是构建一个符合目标后验分布的马尔可夫链。许多 MCMC 算法，如 **吉布斯采样**、**差分进化算法** 以及 PyMC 默认使用的 **NUTS**（No-U-Turn Sampler），都是 **Metropolis-Hastings** 算法的变种。  \n","    \n","<table>  \n","        <tr>  \n","            <td><img src=\"http://gorayni.github.io/assets/posts/gibbs/gibbs2.gif\" alt=\"\" width=\"200\" height=\"200\"></td>  \n","            <td><img src=\"https://matteding.github.io/images/diff_evol.gif\" alt=\"\" width=\"200\" height=\"200\"></td>  \n","            <td><img src=\"https://cdn.kesci.com/upload/image/rjvh3zx4an.gif?imageView2/0/w/640/h/640\" alt=\"\" width=\"200\" height=\"200\"></td>  \n","        </tr>  \n","        <tr>  \n","            <td>吉布斯采样算法</td>  \n","            <td>差分进化算法</td>  \n","            <td>汉密尔顿算法</td>  \n","        </tr>  \n","</table>  \n","\n","\n","通过这些算法，我们可以对难以直接求解的后验分布进行近似。\n","\n","我们将在本节课重点讨论 Metropolis-Hastings (MH) 算法，而不是研究所有的变种。  \n","\n","- 虽然实现该算法需要计算机编程技能，而这些技能并不在本课程的范围之内（例如编写函数和 for 循环），    \n","- 😜ps. 即使没有学会 MH 算法的实现，也不妨碍我们通过 pymc 来实现各种 MCMC 算法。  "]},{"cell_type":"markdown","metadata":{},"source":["## Metropolis-Hastings(MH)算法  \n","\n","在刚才的例子中，我们已经涉及到 MH 算法最朴素的思想：  \n","\n","- 后验分布模型可以通过公式进行推导得到，然而无法对它进行直接采样。  \n","- 我们可以根据后验模型 y 轴的大小来决定 x 轴参数的数量。  \n","  - 例如，我们均匀的从参数的范围(x~[0,1])中抽取 10000个参数样本 $\\mu_i$。  \n","  - 然后我们计算对于每个 $\\mu_i$ 的 $f(\\mu_i)$ 的大小，$f(\\mu_i)$ 越大那么 $\\mu_i$ 被保留的可能性越高。   \n","- 正如之前提到，计算 $f(\\mu_i)$ 是比较困难的，我们可以计算非标准化的 $f(\\mu_i)$。  \n","- 此外，直接在[0,1]中均匀的采样效率太低，我们在接下来会利用 MCMC 状态转移的性质来提高采样效率。  \n","\n","现在我们就来体验这个奇妙的过程。"]},{"cell_type":"markdown","metadata":{},"source":["### 建议分布(proposed distribution)  \n","\n","为了提高采样效率，我们**不会**直接从一个分布中进行大量采样，再进行筛选(也被称为拒绝)，这种方式在复杂分布中效率非常低。\n","\n","因此在 MCMC 中，我们会构造一个建议分布 (proposed distribution) $q(x)$，然后利用 MCMC 状态转移的性质来进行采样。\n","\n","通过建议分布，我们可以在 MCMC 的状态转移过程中构造出一条马尔可夫链。这条链最终会收敛于目标后验分布，使得生成的样本接近真实的目标分布。\n","\n","在刚才所讲的心情状态的变化过程实际上就是一个建议分布的例子。\n","\n","\n",">  \n","![Image Name](https://www.bayesrulesbook.com/bookdown_files/figure-html/ch-7-mh-proposal-1.png)\n"]},{"cell_type":"markdown","metadata":{},"source":["\n","我们已经了解了建议分布的思想。  \n","\n","接下来，我们需要了解**如何根据建议分布进行采样**，以及如何从 **建议分布 $q(x)$ 得到后验分布 $p(x)$** 。"]},{"cell_type":"markdown","metadata":{},"source":["### 接受率 (acceptance probability)  \n","\n","虽然我们了解了当前样本可以根据上一次的样本从建议分布中进行采样 $\\theta^{n} \\sim Normal(\\theta^{n-1}_{k},\\sigma)$。  \n","\n","然而，我们如何判断这个采样是否合理呢？换句话说，我们需要思考是否保留或拒绝这个采样。  \n","- 假设上一次采样的参数值为 $\\theta^{n-1} = 3$， 根据建议分布$q(\\theta) = Normal(0.1,1)$ 我们采样得到参数值 $\\theta^{n} = 1$。  \n","- 而实际上，我们后验分布(或者未标准化的后验分布)为 $p(\\theta) = Normal(5,1)$。  \n","- 显然，$\\theta^{n} = 1$ 在 $p(\\theta)$ 的边缘。那我们是否要保留该采样呢？"]},{"cell_type":"markdown","metadata":{},"source":["**不同接受策略的影响**  \n","\n","* 我们可以考虑三种接受建议的情况：  \n","\n","    1：始终不接受提议。  \n","\n","    2：始终接受提议。  \n","\n","    3：只有当提议(n+1)的后验可能性大于当前(n)值的后验可能性时，才接受提议  \n","\n","* 我们来看看这三种情况对应生成的trace plot  \n","![Image Name](https://www.bayesrulesbook.com/bookdown_files/figure-html/ch7-bad-step2-1.png)  \n","\n","    1. 使得马尔科夫链在采样时一直停在同一个值  \n","\n","    2. 马尔科夫链的采样并不会稳定在某一个范围内  \n","    \n","    3. 采样只停留在$\\mu = 4$附近(只能采到一部分值)  \n","\n","* 因此我们知道，尽管采样应该更多地停留在“高后验可能性的值”，但也不能只取到这附近的值。  \n"]},{"cell_type":"markdown","metadata":{},"source":["**接受率 (acceptance probability)**  \n","\n","可见，选择一个合适的接受策略非常重要。而接受率 ($\\alpha$, acceptance probability)就是为了解决这个问题。  \n","\n","- 首先，我们将从建议模型中抽取一个新的参数 $\\theta^{n+1}$ 的概率为 $q(\\theta^{n+1}|\\theta^{n})$  \n","- 对于是否接受 $\\theta^{n+1}$，我们定义接受概率$\\alpha$  \n","$$  \n","  \\alpha = \\min\\left\\lbrace 1, \\; \\frac{f(\\theta^{n+1})L(\\theta^{n+1}|y)}{f(\\theta^{n})L(\\theta^{n}|y)} \\times \\frac{q(\\theta^{n}|\\theta^{n+1})}{q(\\theta^{n+1}|\\theta^{n})} \\right\\rbrace.  \n","$$  \n","- 别看这公式很复杂，其实很简单。  \n","- 分数的上下分别代表下一个参数$\\theta^{n+1}$和当前参数$\\theta^{n}$的非标准化后验。即我们之前提到，要通过非标准化后验来判断是否接受一个参数。  \n","  - 其中，$f(\\theta)L(\\theta|y)$ 为非标准化后验  \n","  - $q(\\theta^{n}|\\theta^{n+1})$ 部分代表了从建议分布中采样新参数的过程。  \n","- 可以想象，$\\frac{f(\\theta^{n+1})L(\\theta^{n+1}|y)}{f(\\theta^{n})L(\\theta^{n}|y)}$ 大于1且其值越大，表明下一个参数$\\theta^{n+1}$的后验概率越大，因此它越有可能被接受。  \n","- 如果$\\frac{f(\\theta^{n+1})L(\\theta^{n+1}|y)}{f(\\theta^{n})L(\\theta^{n}|y)}$小于1，则代表下一个参数$\\theta^{n+1}$的后验概率过小，因此我们要舍弃它。  \n","\n","所以，对于是否接受或拒绝新的参数 $\\theta^{n+1}$，则有：  \n","$$  \n","\\theta^{(n+1)} =  \n"," \\begin{cases}  \n"," \\theta^{(n+1)} &  \\text{ with probability } \\alpha \\\\  \n"," \\theta^{(n)} &  \\text{ with probability } 1- \\alpha. \\\\  \n"," \\end{cases}  \n"," $$  \n","- 也就是如果我们不接受新的参数，那我们用原来的参数替代现在的参数。  \n","- 这样避免了参数采样被浪费，并且使得概率更大的参数被更多的采样。"]},{"cell_type":"markdown","metadata":{},"source":["总的来说，MH 算法包含两个关键思想和两个关键步骤：  \n","\n","两个关键思想  \n","- 根据非标准化的后验进行参数的接受或拒绝  \n","- 根据 MCMC 的特性设置建议分布来完成状态转移  \n","\n","两个关键步骤  \n","- 设定建议分布  \n","- 根据建议分布的参数、未标准化后验计算接受率"]},{"cell_type":"markdown","metadata":{},"source":["### 代码示例  \n","\n","我们使用代码感受一下这个过程"]},{"cell_type":"code","execution_count":1,"metadata":{},"outputs":[],"source":["import numpy as np\n","import scipy.stats as st\n","import pandas as pd\n","import seaborn as sns"]},{"cell_type":"markdown","metadata":{},"source":["首先，我们假设当前的参数值 $\\theta^{n} = 3$，然后我们根据该参数设定建议分布，并进行一次新的采样。  \n","\n","- 注意，为了方便演示，我们将建议分布(正态分布)的 $\\sigma$ 固定为1。"]},{"cell_type":"code","execution_count":2,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["从建议分布中新采样 θ(n+1)为： 4.668047321311954\n"]}],"source":["np.random.seed(2024)\n","\n","current = 3                             # 假设theta(n)为3\n","\n","proposal = st.norm(current, 1).rvs()    # 从当前正态分布中抽出一个样本\n","\n","print(\"从建议分布中新采样 θ(n+1)为：\",proposal)"]},{"cell_type":"markdown","metadata":{},"source":["接着，我们根据新采样得到的参数计算其相关的接受率。  \n","- 注意，我们假设先验正态分布的参数为：mean = 3, sigma = 1  \n","- 另外，我们假设似然模型仅包含一个数据：Y = 6"]},{"cell_type":"code","execution_count":3,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["后验比为： 153.2136146465854 , alpha为: 1\n"]}],"source":["# 设置先验\n","prior = st.norm(loc = 3, scale = 1)\n","def likelihood(theta):\n","    Y = 6  # 假设数据 Y 为 6\n","    return st.norm(loc = theta, scale = 0.75).pdf(Y)  # 注意：这里为方便演示固定 scale = 0.75\n","    \n","\n","# 计算建议位置(n+1)的未归一化的后验概率值（先验*似然）\n","proposal_posterior = prior.pdf(proposal) * likelihood(proposal)\n","\n","# 计算当前位置(n)的未归一化的后验概率值（先验*似然）\n","current_posterior = prior.pdf(current) * likelihood(current)\n","\n","# 计算接受概率α，为两者概率值之比\n","alpha = min(1,proposal_posterior/current_posterior)\n","\n","# 打印出接受概率α\n","print(\"后验比为：\", proposal_posterior/current_posterior, \", alpha为:\", alpha)"]},{"cell_type":"markdown","metadata":{},"source":["最后，我们根据接受率 $\\alpha$来决定是否接受建议分布的参数作为新的采样值。"]},{"cell_type":"code","execution_count":4,"metadata":{},"outputs":[{"data":{"text/plain":["4.668047321311954"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["# 根据接受概率α进行抽样，抽样内容为建议位置和当前位置\n","next_stop = np.random.choice([proposal, current], 1, p=[alpha,1-alpha])\n","\n","# 打印出下一个位置的值\n","next_stop[0]\n","\n","#从第一段代码我们可以看到此时的接受概率α=1，因此接受了建议值作为我们的下一个值"]},{"cell_type":"markdown","metadata":{},"source":["**定义单次采样函数**  \n","\n","我们可以直接定义一个函数，将刚刚的操作全都结合在一起，这样当我们想进行抽样的时候，不用重复写代码"]},{"cell_type":"code","execution_count":5,"metadata":{},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>proposal</th>\n","      <th>alpha</th>\n","      <th>next_stop</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>3.091205</td>\n","      <td>1</td>\n","      <td>3.091205</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   proposal  alpha  next_stop\n","0  3.091205      1   3.091205"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["def one_mh_iteration(current, sigma = 1):\n","\n","    \"\"\"\n","    def后面为函数值，current为输入值，作为建议分布(正态分布)的均值\n","    \n","    接下来的代码和之前一样\n","\n","    return 则是该函数返回的值，我们将建议值，接受概率，和下一个位置这三个值组成了一个数据框进行返回\n","    \"\"\"\n","    proposal = st.norm(current, sigma).rvs()\n","\n","    prior = st.norm(loc = 3, scale = 1)\n","    def likelihood(theta):\n","        # 假设数据 Y 为 6\n","        Y = 6\n","        return st.norm(loc = theta, scale = 0.75).pdf(Y)\n","        \n","    proposal_posterior = prior.pdf(proposal) * likelihood(proposal)\n","    current_posterior = prior.pdf(current) * likelihood(current)\n","    alpha = min(1,proposal_posterior/current_posterior)\n","    next_stop = np.random.choice([proposal, current], 1, p=[alpha,1-alpha])\n","    return pd.DataFrame({\"proposal\":[proposal],\n","                         \"alpha\":[alpha], \n","                         \"next_stop\":[next_stop[0]]})\n","np.random.seed(8)\n","one_mh_iteration(current=3)"]},{"cell_type":"code","execution_count":6,"metadata":{},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>proposal</th>\n","      <th>alpha</th>\n","      <th>next_stop</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>3.849313</td>\n","      <td>1</td>\n","      <td>3.849313</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   proposal  alpha  next_stop\n","0  3.849313      1   3.849313"]},"execution_count":6,"metadata":{},"output_type":"execute_result"}],"source":["# 变换不同的随机数种子，其实也是生成不同的建议值\n","np.random.seed(83)\n","one_mh_iteration(current=3)"]},{"cell_type":"markdown","metadata":{},"source":["**多次采样**  \n","\n","上述函数只进行了一次采样，即当前位置为3时，下一个可能采样的结果  \n","\n","基于当前位置，提出下一个采样值，接受或拒绝它。那么新的采样值就变成了当前位置，我们需要不断重复这个过程"]},{"cell_type":"code","execution_count":7,"metadata":{},"outputs":[],"source":["def mh_tour(N, sigma = 1):\n","\n","    \"\"\"\n","    N为迭代次数，sigma为正态建议分布的标准差\n","\n","    我们在单次采样函数的基础上叠加了一个循环\n","    将每次的采样结果存在mu[i]中，\n","    在每次采样结束后，将采样结果替换为当前位置\n","\n","    返回值为迭代次数，和每次采样得到的结果\n","    \"\"\"\n","    current = 3\n","    mu = np.zeros(N)\n","\n","    for i in range(N):\n","        sim = one_mh_iteration(current,sigma)\n","        mu[i] = sim[\"next_stop\"][0]\n","        current = sim[\"next_stop\"][0]\n","    \n","    return pd.DataFrame({\"iteration\": range(1,N+1),\n","                         'mu': mu})"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>iteration</th>\n","      <th>mu</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>4995</th>\n","      <td>4996</td>\n","      <td>4.528634</td>\n","    </tr>\n","    <tr>\n","      <th>4996</th>\n","      <td>4997</td>\n","      <td>4.528634</td>\n","    </tr>\n","    <tr>\n","      <th>4997</th>\n","      <td>4998</td>\n","      <td>4.745413</td>\n","    </tr>\n","    <tr>\n","      <th>4998</th>\n","      <td>4999</td>\n","      <td>5.847077</td>\n","    </tr>\n","    <tr>\n","      <th>4999</th>\n","      <td>5000</td>\n","      <td>5.847077</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["      iteration        mu\n","4995       4996  4.528634\n","4996       4997  4.528634\n","4997       4998  4.745413\n","4998       4999  5.847077\n","4999       5000  5.847077"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["# 调用定义好的函数，将采样次数设为5000\n","np.random.seed(84735)\n","mh_simulation = mh_tour(N=5000)\n","mh_simulation.tail()"]},{"cell_type":"markdown","metadata":{},"source":["**采样结果图示**"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[{"data":{"text/plain":["Text(0, 0.5, 'mu')"]},"execution_count":9,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 2000x500 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import matplotlib.pyplot as plt\n","\n","#生成一行两列的画布\n","fig, axs = plt.subplots(1, 2, figsize=(20, 5))\n","\n","#density plot：在第一列绘制出采样结果的分布\n","axs[0].hist(mh_simulation[\"mu\"], \n","            edgecolor = \"white\",\n","            color=\"grey\",\n","            alpha = 0.7,\n","            bins = 20,\n","            density = True)\n","axs[0].set_xlabel(\"mu\", fontsize=16)\n","axs[0].set_ylabel(\"density\", fontsize=16)\n","\n","# 绘制分布外围线条\n","x_norm = np.linspace(2,10,10000)                  \n","y_norm = st.norm.pdf(x_norm, loc=mh_simulation[\"mu\"].mean(), scale=mh_simulation[\"mu\"].std())\n","\n","axs[0].plot(x_norm, y_norm, color='blue')\n","\n","#trace plot：在第二列绘制出每一次的采样结果\n","axs[1].plot(mh_simulation[\"iteration\"], mh_simulation[\"mu\"],\n","            color=\"grey\",)\n","axs[1].set_xlabel(\"iteration\", fontsize=16)\n","axs[1].set_ylabel(\"mu\", fontsize=16)"]},{"cell_type":"markdown","metadata":{},"source":["我们可以使用 arviz 简化这个绘图的过程"]},{"cell_type":"code","execution_count":14,"metadata":{},"outputs":[{"data":{"text/plain":["(2.0, 10.0)"]},"execution_count":14,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x200 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import arviz as az\n","import matplotlib.pyplot as plt\n","\n","ax = az.plot_trace({\"mu\":mh_simulation[\"mu\"]})\n","\n","ax[0, 0].set_xlim(2, 10)\n"]},{"cell_type":"markdown","metadata":{},"source":["### 调试(Tuning)Metropolis-Hastings 算法  \n","\n","在建议分布 $\\mu_{n+1} | \\mu_{n} \\; \\sim \\; \\text{Normal}(\\mu_{n}, \\sigma)$中，$\\sigma$反映了 建议选项的分布宽度，对$\\sigma$ 的选择也会影响马尔科夫链的表现  \n","\n","🧐思考：我们仍然使用MH算法，尝试三种不同的$\\sigma$  \n","* $\\sigma = 0.01$  \n","* $\\sigma = 1$  \n","* $\\sigma = 100$  \n","    \n","请你判断以下的轨迹图和密度图分别对应上述哪种情况  \n","\n","![Image Name](https://www.bayesrulesbook.com/bookdown_files/figure-html/ch7-bad-idea-1.png)  \n","\n","\n","可以结合以下代码进行判断"]},{"cell_type":"code","execution_count":20,"metadata":{},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","import arviz as az\n","import scipy.stats as st\n","import pandas as pd\n","\n","def one_mh_iteration(current, sigma = 1):\n","\n","    \"\"\"\n","    def后面为函数值，current为输入值，作为建议分布(正态分布)的均值\n","    \n","    接下来的代码和之前一样\n","\n","    return 则是该函数返回的值，我们将建议值，接受概率，和下一个位置这三个值组成了一个数据框进行返回\n","    \"\"\"\n","    proposal = st.norm(current, sigma).rvs()\n","\n","    prior = st.norm(loc = 3, scale = 1)\n","    def likelihood(theta):\n","        # 假设数据 Y 为 6\n","        Y = 6\n","        return st.norm(loc = theta, scale = 0.75).pdf(Y)\n","        \n","    proposal_posterior = prior.pdf(proposal) * likelihood(proposal)\n","    current_posterior = prior.pdf(current) * likelihood(current)\n","    alpha = min(1,proposal_posterior/current_posterior)\n","    next_stop = np.random.choice([proposal, current], 1, p=[alpha,1-alpha])\n","    return pd.DataFrame({\"proposal\":[proposal],\n","                         \"alpha\":[alpha], \n","                         \"next_stop\":[next_stop[0]]})\n","\n","def mh_tour(N, sigma = 1):\n","\n","    \"\"\"\n","    N为迭代次数，sigma为正态建议分布的标准差\n","\n","    我们在单次采样函数的基础上叠加了一个循环\n","    将每次的采样结果存在mu[i]中，\n","    在每次采样结束后，将采样结果替换为当前位置\n","\n","    返回值为迭代次数，和每次采样得到的结果\n","    \"\"\"\n","    current = 3\n","    mu = np.zeros(N)\n","\n","    for i in range(N):\n","        sim = one_mh_iteration(current,sigma)\n","        mu[i] = sim[\"next_stop\"][0]\n","        current = sim[\"next_stop\"][0]\n","    \n","    return pd.DataFrame({\"iteration\": range(1,N+1),\n","                         'mu': mu})"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["#===========================================================================\n","#                            请修改 ... 中的值。\n","#===========================================================================\n","np.random.seed(84735)\n","\n","mh_simulation = mh_tour(N=5000, sigma= ...)\n","az.plot_trace({\"mu\": mh_simulation[\"mu\"]})"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["#===========================================================================\n","#                            可以自行复制代码多试几次\n","#===========================================================================\n","mh_simulation = mh_tour(N=5000, sigma= ...)\n","az.plot_trace({\"mu\": mh_simulation[\"mu\"]})"]},{"cell_type":"markdown","metadata":{},"source":["**总结**  \n","\n","* 当$w = 0.01$时：  \n","\n","    建议分布的范围很窄，比如$Normal(3, 0.001)$，这会导致下一个建议值和当前值非常接近，则$f(\\mu')L(\\mu'|y) \\approx f(\\mu)L(\\mu|y)$  \n","    $$  \n","    \\alpha = \\min\\left\\lbrace 1, \\; \\frac{f(\\mu')L(\\mu'|y)}{f(\\mu)L(\\mu|y)} \\right\\rbrace \\approx \\min\\left\\lbrace 1, \\; 1 \\right\\rbrace \\; = 1 .  \n","    $$  \n","    那么我们很容易接受下一个采样值，但尽管马尔科夫链一直在转移，但探索的范围太窄了，我们可以看到采样一直在3附近  \n","\n","* 当$w = 100$时：  \n","\n","    类似的，我们可以推知此时建议分布的范围太宽了，超出了$\\mu$可能的取值  \n","\n","    下一个建议值和当前值间隔太远，这会导致我们经常拒绝下一个采样值，多次停在当前位置。"]},{"cell_type":"markdown","metadata":{},"source":["**补充介绍：细致平衡 (detail Balance)**  \n","\n","我们已经感受到，从一个自定义的建议分布$q(x)$中采样，竟然可以得到关于参数的后验分布$p(x)$。  \n","\n","🤔这非常神奇，这到底是怎么做到的？  \n","\n","一切的关键在于，MCMC 的性质：细致平衡 (detail Balance)。  \n","- 正如之前关于心情的例子一样，只要我们每天都记录自己的开心程度。我们就可以得到关于自己心境的分布。 也对应了参数的**后验分布**。  \n","- 这个概率分布代表了心境的乐观水平，分布的均值越大，代表个体越乐观。  \n","- 而我们在最开始记录心情之前，并不知道这个后验分布是什么形态的。  \n","- 我们只是按照**转移矩阵**提供的概率转化心情。换句话说，心情受到影响后如何转化是我们确定的(建议分布)，但我们却不清楚自己的乐观程度(后验分布)。  \n","- 最后需要注意的是，后验分布也**与最开始的心情无关**。无论最开始是开心还是悲伤，都不影响个体总体上乐观的心态。"]},{"cell_type":"markdown","metadata":{},"source":["![Image Name](https://cdn.kesci.com/upload/image/rk6x7auvhk.png?imageView2/0/w/640/h/640)  \n"]},{"cell_type":"markdown","metadata":{},"source":["它的数学基础在于，当心情无限演化下去，状态转移的概率达到平衡，也就是所谓的细致平衡：  \n","\n","假设，状态转移矩阵为 P  \n","\n","| 心情 | 开心$\\theta^{(n-1)}_{1}$ | 冷静$\\theta^{(n-1)}_{2}$ | 悲伤$\\theta^{(n-1)}_{3}$ | ... |  \n","| :----: | :----: | :----: | :----: | :----: |  \n","| 开心$\\theta^{(n)}_{1}$ | 0.5 | 0.25 | 0.25 | ... |  \n","| 冷静$\\theta^{(n)}_{2}$ | 0.5 | 0 | 0.5 | ... |  \n","| 悲伤$\\theta^{(n)}_{3}$ | 0.25 | 0.25 | 0.5 | ... |  \n","| ... | ... | ... | ... | ... |  \n","\n","假设每天记录 10000个个体的心情，我们可以用 $\\pi$ 来描述这个群体的心情分布。  \n","\n","- 可以想象，第二天这 10000个个体的心情可能发生变化，也就是 $\\pi * P$ (矩阵乘法)。  \n","- 由于这 10000个个体的乐观程度不太可能瞬间变化，所以在总体上，他们的分布不换变化，也就是 $\\pi * P = \\pi$。  \n","- 那么就会有 $\\pi(i)* P(i,j) = \\pi(j)* P(j,i)$。其中 i 代表上面矩阵的行，j代表矩阵的列。  \n","\n","其中，满足上述公式的 $\\pi$ 就是参数的后验分布。  \n","- 然而，我们一开始并不知道 $P$。  \n","- 但我们可以通过加入建议分布$q(x)$和拒绝率$\\alpha$来替代 $P$。  \n","- 得到： $\\pi(i)* q(i,j) * \\alpha(i,j) = \\pi(j)* q(j, i) * \\alpha(j, i)$  \n","\n","也就是，我们通过建议分布产生参数*拒绝率的方式来采样模拟了P。  \n","- 一个不恰当的比喻：状态转移矩阵 P 是你真实的乐观程度，但只有上帝知道你的本来面目 P。  \n","- 然而，你能认识到自己当下的情绪 Q，并且在漫长人生中，你可以识别那些不属于自己的情绪 $\\alpha$ 。  \n","- 最后，你对自己的认识越来越接近上帝....  \n"]},{"cell_type":"markdown","metadata":{},"source":["最后，推荐 MCMC 讲解最好的视频(没有之一)：【蒙特卡洛（Monte Carlo, MCMC）方法的原理和应用】 https://www.bilibili.com/video/BV17D4y1o7J2/?share_source=copy_web&vd_source=4b5b4646c3f53f1b80954c381226c913  \n","\n","如果还是不懂 MCMC 原理，那放弃也行.....  \n","\n","不了解 MCMC 原理，并不影响对于它的使用。"]},{"cell_type":"markdown","metadata":{},"source":["### 小结\n","\n","无论是在这些相对简单的单参数模型设置中，还是在更复杂的模型设置中，Metropolis-Hastings 算法都是通过两步之间的迭代，从后验中产生近似样本：  \n","- 设定建议分布  \n","- 根据建议分布的参数、未标准化后验计算接受率  \n","\n","本节课我们只考虑了一种 MCMC 算法，即 Metropolis-Hastings。这种算法虽然功能强大，但也有其局限性。  \n","- 在以后的章节中，我们的贝叶斯模型将增加大量参数。调整 Metropolis-Hastings 算法以充分探索每个参数会变得很笨重。  \n","- 然而，即使 Metropolis-Hastings 算法的实用性达到了极限，它仍然是一套更灵活的 MCMC 工具的基础，包括自适应 Metropolis-Hastings、Gibbs 和 Hamiltonian Monte Carlo (HMC) 算法。其中，HMC 是 pymc 默认使用的算法。"]},{"cell_type":"markdown","metadata":{},"source":["## PyMC实战\n","\n","在上一部分，我们学习了 MCMC 算法的基本原理，并通过 Python 代码实现了一次简单的 Metropolis-Hastings 迭代。\\\n","但随着模型复杂性提升，我们发现手动实现 MCMC 代码可能会变得非常繁琐.\n","\n","同时在第五课中，我们使用网格法对 Beta-Binomial 模型进行了推断，并初步介绍了 PyMC。\\\n","下面我们会深入讲解如何利用 PyMC，借助 MCMC 方法进行高效的贝叶斯推断。"]},{"cell_type":"markdown","metadata":{},"source":["### 为什么选择PyMC？\n","\n","在实际操作中，PyMC 封装了许多底层 MCMC 算法，如 Metropolis-Hastings 和 NUTS（No-U-Turn Sampler），使得用户可以将更多精力集中在模型构建和推断结果的分析上。\n","\n","在贝叶斯中，PyMC 提供了一套丰富的接口，覆盖了贝叶斯建模的各个环节，包括模型定义、设置先验和似然分布、采样、后验预测和诊断。\n","\n","接下来我们介绍 PyMC 的基本使用流程和核心模块。\n","\n","1. **模型定义**：PyMC 中所有的模型都是在 `pm.Model()`语句中定义的。用户可以在其中指定模型的参数（即先验分布）和观测数据的分布（即似然函数）。\n","2. **概率分布（Distributions）**：PyMC 支持多种常见的概率分布，例如 Normal, Beta, Bernoulli, Binomial, Poisson 等，用于定义先验和似然分布。用户可以通过`pm.<Distribution>`的形式来定义参数的先验和似然。\n","3. **采样（Sampling）**：PyMC 使用多种采样算法进行后验采样,如Metropolis-Hastings和NUTS（No-U-Turn Sampler）。\n","\n","4. **后验预测**：PyMC 支持从后验分布生成新的观测值，根据`pm.sample_posterior_predictive()`它可以帮助我们验证模型的合理性，即模型生成的数据是否与真实数据一致。\n","\n","5. **诊断和可视化**：PyMC 提供了与 Arviz 包的集成，用户可以使用 `az.plot_trace()`等函数可视化参数的后验分布和采样轨迹，并使用`az.summary()`查看后验统计量。这些工具有助于诊断采样的收敛性和质量。"]},{"cell_type":"markdown","metadata":{},"source":["使用 PyMC 进行贝叶斯建模通常包括以下步骤（以beta-binomial模型进行演示）：\n"]},{"cell_type":"markdown","metadata":{},"source":["\n","## A Beta-Binomial example in pymc  \n","\n","假设我们进行了一项随机点运动任务的实验，每个试验中参与者判断正确的概率用 $\\pi$ 表示。\n","\n","**模型假设**\n","\n","- 我们假设参与者判断正确的概率 $\\pi$ 是从 **Beta 分布**中抽样的：\n","\n","$$  \n","\\begin{equation}  \n","\\pi \\sim \\text{Beta}(\\alpha, \\beta)  \n","\\end{equation}  \n","$$  \n","\n","- 在每次试验中，参与者的成功次数 $Y$ 服从一个 **Binomial分布**：\n","\n","$$  \n","\\begin{equation}  \n","Y \\sim \\text{Binomial}(n, \\pi)  \n","\\end{equation}  \n","$$  \n","\n","其中，$n$是试验的总次数，$Y$是成功次数。\n","\n","**模型设定**\n","\n","在这个例子中，我们可以使用Beta-Binomial 模型来表示：\n","\n","> 先验分布为：$\\pi    \\sim \\text{Beta}(2, 2)$  \n","> 似然函数为：$Y|\\pi  \\sim \\text{Bin}(10, \\pi)$  \n","> 总试验数为10，成功次数为9 $(Y = 9)$  \n","\n","\n","接下来，我们将使用 Pymc 来表达和设定 Beta-Binomial 模型"]},{"cell_type":"code","execution_count":1,"metadata":{},"outputs":[],"source":["import pymc as pm\n","import arviz as az"]},{"cell_type":"code","execution_count":2,"metadata":{},"outputs":[],"source":["# 定义观测值Y=9\n","Y = 9\n","\n","# 创建一个 PyMC 模型名为 bb_model\n","bb_model = pm.Model()\n","\n","# 使用with语句将模型与变量联系起来\n","with bb_model:\n","    # 定义一个符合beta先验分布的变量pi\n","    pi = pm.Beta('pi', alpha=2, beta=2)\n","    # 定义符合binomial分布的变量likelihood，其中总次数为10，成功概率为pi，观测值为Y\n","    likelihood = pm.Binomial('likelihood', n=10, p=pi, observed=Y)"]},{"cell_type":"markdown","metadata":{},"source":["**代码解释**  \n","\n","```python  \n","Y = 9  \n","\n","bb_model = pm.Model()  \n","\n","with bb_model:  \n","    pi = pm.Beta('pi', alpha=2, beta=2)  \n","    likelihood = pm.Binomial('likelihood', n=10, p=pi, observed=Y)  \n","```\n","\n","在pymc中，一个模型的定义通常包含了先验和似然两部分(其复杂性视模型复杂程度而定)：  \n","\n","1. 设立容器  \n","    * 在pymc中，你需要创建一个`pm.Model()`来容纳你模型中的变量  \n","\n","    * 接下来你需要定义模型里的各种参数，即`with bb_model:`，表明接下来你对模型中各参数的设定，都会被添加到该模型中  \n","\n","    * 或者也可以直接一步写成：`with pm.Model() as bb_model:`  \n","\n","2. 定义先验  \n","    * 在这个例子中，我们需要对$\\pi$进行定义  \n","\n","3. 定义似然  \n","    * 我们通过observed = Y，将收集到的数据传入似然函数中  \n"]},{"cell_type":"markdown","metadata":{},"source":["### 模型可视化  \n","\n","可以通过PyMC3自带的可视化工具将模型关系可视化"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[{"data":{"text/html":["<img src=\"https://cdn.kesci.com/upload/rt/DBA902FA6BDC417091875E940BCDC04F/s2ldvx3gg1.svg\">"],"text/plain":["<graphviz.graphs.Digraph at 0x7fad62a4d1c0>"]},"metadata":{},"output_type":"display_data"}],"source":["pm.model_to_graphviz(bb_model)"]},{"cell_type":"markdown","metadata":{},"source":["### 使用mcmc进行采样  \n","\n","在以下例子中，将 MCMC 采样方法得到的参数样本赋值为 `trace`。  \n","- 使用 `sample` 方法进行 MCMC 采样模拟过程。  \n","- 设置参数 `draws` 来控制 MCMC 采样的次数。  \n","- `chains` 表示同时运行几条MCMC链。  \n","\n","我们可以使用 `arviz` 的方法 `plot_trace` 来可视化该结果  \n","- 左图为参数分布图  \n","- 右图为 trace 图，代表随着采样的进行(即x轴1-5000次采样)，每个参数值的大小(即y轴为每个采样参数的大小)。"]},{"cell_type":"code","execution_count":7,"metadata":{},"outputs":[{"name":"stderr","output_type":"stream","text":["Auto-assigning NUTS sampler...\n","Initializing NUTS using jitter+adapt_diag...\n","Sequential sampling (1 chains in 1 job)\n","NUTS: [pi]\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"af34dc94f88146e5a40a2f49a01e94d6","version_major":2,"version_minor":0},"text/plain":["Output()"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"],"text/plain":[]},"metadata":{},"output_type":"display_data"},{"name":"stderr","output_type":"stream","text":["Sampling 1 chain for 1_000 tune and 5_000 draw iterations (1_000 + 5_000 draws total) took 1 seconds.\n","Only one chain was sampled, this makes it impossible to run some convergence checks\n"]},{"data":{"text/plain":["array([[<Axes: title={'center': 'pi'}>, <Axes: title={'center': 'pi'}>]],\n","      dtype=object)"]},"execution_count":7,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x200 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["#采样过程仍在该容器中进行\n","with bb_model:\n","    trace = pm.sample(draws=5000,                   # 使用mcmc方法进行采样，draws为采样次数\n","                      chains=1,                     # 设置MCMC的链数\n","                      random_seed=84735)            # 设置随机状态，以获得与notebook相同的结果\n","\n","# 可视化采样结果\n","az.plot_trace(trace)"]},{"cell_type":"markdown","metadata":{},"source":["### 采样的时间进程  \n","\n","下图展示了第一条Makov链的前20个采样结果和前200个结果  \n"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"data":{"text/plain":["array([[<Axes: title={'center': 'pi'}>, <Axes: title={'center': 'pi'}>]],\n","      dtype=object)"]},"execution_count":8,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x200 with 2 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x200 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# 选取第一条Makov链的前20个采样结果和前200个结果\n","# 从trace中提取pi的值，使用sel(chain=0)表示为选择第一条markov链。使用.values[:20]表示选取前20个采样结果\n","samples_20 = trace.posterior[\"pi\"].sel(chain=0).values[:20]\n","samples_200 = trace.posterior[\"pi\"].sel(chain=0).values[:200]\n","\n","# 绘图\n","# az.plot_trace表示绘制前20个采样结果的轨迹图，其中pi为变量名，samples_20为采样结果\n","az.plot_trace({\"pi\": samples_20})\n","az.plot_trace({\"pi\": samples_200})"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>pi</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>0.741947</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>0.544469</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>0.858457</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>0.415141</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>0.739664</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>4995</th>\n","      <td>0.730776</td>\n","    </tr>\n","    <tr>\n","      <th>4996</th>\n","      <td>0.938275</td>\n","    </tr>\n","    <tr>\n","      <th>4997</th>\n","      <td>0.821699</td>\n","    </tr>\n","    <tr>\n","      <th>4998</th>\n","      <td>0.821699</td>\n","    </tr>\n","    <tr>\n","      <th>4999</th>\n","      <td>0.821699</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>5000 rows × 1 columns</p>\n","</div>"],"text/plain":["            pi\n","0     0.741947\n","1     0.544469\n","2     0.858457\n","3     0.415141\n","4     0.739664\n","...        ...\n","4995  0.730776\n","4996  0.938275\n","4997  0.821699\n","4998  0.821699\n","4999  0.821699\n","\n","[5000 rows x 1 columns]"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["import pandas as pd\n","post_pi = pd.DataFrame({\"pi\": trace.posterior[\"pi\"].values.reshape(-1)})\n","post_pi"]},{"cell_type":"markdown","metadata":{},"source":["### 采样结果可视化  \n","\n","* 将采样结果(5000次采样)对比真实的后验分布(黑线)Beta(11, 3)  \n","\n","* 可以看到这个采样结果很好地近似了后验分布"]},{"cell_type":"code","execution_count":15,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1500x400 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import matplotlib.pyplot as plt\n","import seaborn as sns\n","import numpy as np\n","import scipy.stats as st \n","\n","fig, (axs1, axs2) = plt.subplots(1, 2, figsize=(15, 4))\n","\n","#绘制采样结果直方图\n","sns.histplot(data=post_pi, \n","             x=\"pi\", \n","             bins=30,\n","             ax=axs1,\n","             edgecolor='#20699d', \n","             color=\"#6497b1\",\n","             alpha = 1)\n","\n","#绘制采样结果密度分布图\n","sns.kdeplot(data=post_pi,\n","             x=\"pi\",\n","             color='#6497b1',\n","             fill=True,\n","             alpha = 1,\n","             ax=axs2)\n","\n","#绘制真实后验分布图\n","x = np.linspace(0.2, 1, 10000)\n","# 真实的后验分布 beta（alpha + y, beta + n - y）\n","y = st.beta.pdf(x, 11, 3)\n","axs2.plot(x, y, color='black')\n","\n","sns.despine()"]},{"cell_type":"markdown","metadata":{},"source":["## 练习  \n","> 📃以**Normal-Normal模型**为例来练习使用pymc进行MCMC模拟    \n","\n","在lec5中，我们利用基于**Normal-Normal模型**的例子练习了网格近似法来估计参数。\n","\n","接下来，我们基于 Normal-Normal 再次对平均反应时间和标准差进行推断。不过这次，我们将使用 PyMC 实现 MCMC 采样，而不是网格法.\n","\n","**模型设定：**  \n","- 假设 $\\mu$ 是参与者在随机点运动任务中的**平均反应时间**（单位：ms）。\n","- 假设 $\\sigma$ 是参与者在随机点运动任务中的**标准差**（单位：ms）。  \n","  \n","**先验分布**  \n","我们对参与者的反应时间有一个初步的假设：\n","- 先验分布设为正态分布，平均反应时间$\\mu$约为 300 ms，标准差 $\\sigma$ 为 50 ms。\n","- 因此， $\\mu$ 的先验分布可以表示为\n","$$\n","\\mu \\sim \\text{Normal}(300, 50)\n","$$  \n","\n","**观测数据**  \n","- 观测数据 $Y$ 表示参与者在实验中实际的反应时间。\n","- 假设我们收集了被试完成 5 次实验的反应时间：\n","$$\n","Y = [320, 310, 280, 340, 300] ms\n","$$\n","\n","- 反应时间 $Y$ 的标准差 $\\sigma$ 被认为是已知的，$\\sigma$ = 20 ms。\n","\n","**条件模型** \n","- 观测数据 $Y_i$服从一个均值为$\\mu$、标准差为 $\\sigma$ 的正态分布：\n","\n","$$\n","Y_i |\\mu \\stackrel{ind}{\\sim} \\text{Normal}(\\mu, \\sigma^2)\n","\\tag{1}\n","$$\n","\n","<div style=\"padding-bottom: 30px;\"></div>\n","\n","\n","- 结合先验分布，完整的模型表示为：\n","\n","$$  \n","\\begin{equation}  \n","\\begin{split}  \n","Y_i|\\mu & \\stackrel{ind}{\\sim} \\text{Normal}(\\mu, \\sigma^2) \\\\  \n","\\mu & \\sim \\text{Normal}(\\mu_0, \\sigma_0^2) . \\\\  \n","\\end{split}  \n","\\tag{1}  \n","\\end{equation}  \n","$$  \n","\n","<div style=\"padding-bottom: 30px;\"></div>"]},{"cell_type":"code","execution_count":41,"metadata":{"collapsed":false,"id":"D29892D9FCFB40EB970897403DB9B464","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[],"source":["import pymc as pm\n","import arviz as az"]},{"cell_type":"code","execution_count":42,"metadata":{"collapsed":false,"id":"512B9E9C88FC4ABD8AD53894D80D291B","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[],"source":["#===========================================================================\n","#                            请修改 ... 中的值。\n","#===========================================================================\n","\n","observed_data = [...]\n","\n","#1. 设立容器\n","\n","with pm.Model() as nn_model:\n","    #2. 定义先验\n","    mu_prior = pm.Normal('...', mu= ..., sigma= ...)\n","    #3. 定义似然\n","    Y_obs = pm.Normal('...', mu=..., sigma= ..., observed=...)"]},{"cell_type":"code","execution_count":43,"metadata":{"collapsed":false,"id":"5DF28BEE427F4F81B0C04D2ED2DF3676","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["Auto-assigning NUTS sampler...\n","Initializing NUTS using jitter+adapt_diag...\n","Sequential sampling (1 chains in 1 job)\n","NUTS: [mu_prior]\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"4be1233f079949e290e2a57bc3c3d936","version_major":2,"version_minor":0},"text/plain":["Output()"]},"metadata":{},"output_type":"display_data"},{"data":{"text/html":["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"],"text/plain":[]},"metadata":{},"output_type":"display_data"},{"name":"stderr","output_type":"stream","text":["Sampling 1 chain for 1_000 tune and 5_000 draw iterations (1_000 + 5_000 draws total) took 1 seconds.\n","Only one chain was sampled, this makes it impossible to run some convergence checks\n"]}],"source":["#===========================================================================\n","#                            请修改 ... 中的值。\n","#===========================================================================\n","with nn_model:\n","    trace = pm.sample(draws= ...,                    # 例如采样次数设为500-5000次\n","                      chains=1,                     # 链为1条\n","                      random_seed=84735)"]},{"cell_type":"code","execution_count":44,"metadata":{"collapsed":false,"id":"40B74FC26203418183EE59E85E43E10C","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[{"data":{"text/html":["\n","            <div>\n","              <div class='xr-header'>\n","                <div class=\"xr-obj-type\">arviz.InferenceData</div>\n","              </div>\n","              <ul class=\"xr-sections group-sections\">\n","              \n","            <li class = \"xr-section-item\">\n","                  <input id=\"idata_posterior19436e57-87ec-4921-911f-19b1978dd3fe\" class=\"xr-section-summary-in\" type=\"checkbox\">\n","                  <label for=\"idata_posterior19436e57-87ec-4921-911f-19b1978dd3fe\" class = \"xr-section-summary\">posterior</label>\n","                  <div class=\"xr-section-inline-details\"></div>\n","                  <div class=\"xr-section-details\">\n","                      <ul id=\"xr-dataset-coord-list\" class=\"xr-var-list\">\n","                          <div style=\"padding-left:2rem;\"><div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n","<defs>\n","<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n","<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n","<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","</symbol>\n","<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n","<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n","<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","</symbol>\n","</defs>\n","</svg>\n","<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n"," *\n"," */\n","\n",":root {\n","  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n","  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n","  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n","  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n","  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n","  --xr-background-color: var(--jp-layout-color0, white);\n","  --xr-background-color-row-even: var(--jp-layout-color1, white);\n","  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n","}\n","\n","html[theme=dark],\n","body[data-theme=dark],\n","body.vscode-dark {\n","  --xr-font-color0: rgba(255, 255, 255, 1);\n","  --xr-font-color2: rgba(255, 255, 255, 0.54);\n","  --xr-font-color3: rgba(255, 255, 255, 0.38);\n","  --xr-border-color: #1F1F1F;\n","  --xr-disabled-color: #515151;\n","  --xr-background-color: #111111;\n","  --xr-background-color-row-even: #111111;\n","  --xr-background-color-row-odd: #313131;\n","}\n","\n",".xr-wrap {\n","  display: block !important;\n","  min-width: 300px;\n","  max-width: 700px;\n","}\n","\n",".xr-text-repr-fallback {\n","  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n","  display: none;\n","}\n","\n",".xr-header {\n","  padding-top: 6px;\n","  padding-bottom: 6px;\n","  margin-bottom: 4px;\n","  border-bottom: solid 1px var(--xr-border-color);\n","}\n","\n",".xr-header > div,\n",".xr-header > ul {\n","  display: inline;\n","  margin-top: 0;\n","  margin-bottom: 0;\n","}\n","\n",".xr-obj-type,\n",".xr-array-name {\n","  margin-left: 2px;\n","  margin-right: 10px;\n","}\n","\n",".xr-obj-type {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-sections {\n","  padding-left: 0 !important;\n","  display: grid;\n","  grid-template-columns: 150px auto auto 1fr 20px 20px;\n","}\n","\n",".xr-section-item {\n","  display: contents;\n","}\n","\n",".xr-section-item input {\n","  display: none;\n","}\n","\n",".xr-section-item input + label {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-item input:enabled + label {\n","  cursor: pointer;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-item input:enabled + label:hover {\n","  color: var(--xr-font-color0);\n","}\n","\n",".xr-section-summary {\n","  grid-column: 1;\n","  color: var(--xr-font-color2);\n","  font-weight: 500;\n","}\n","\n",".xr-section-summary > span {\n","  display: inline-block;\n","  padding-left: 0.5em;\n","}\n","\n",".xr-section-summary-in:disabled + label {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-summary-in + label:before {\n","  display: inline-block;\n","  content: '►';\n","  font-size: 11px;\n","  width: 15px;\n","  text-align: center;\n","}\n","\n",".xr-section-summary-in:disabled + label:before {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-summary-in:checked + label:before {\n","  content: '▼';\n","}\n","\n",".xr-section-summary-in:checked + label > span {\n","  display: none;\n","}\n","\n",".xr-section-summary,\n",".xr-section-inline-details {\n","  padding-top: 4px;\n","  padding-bottom: 4px;\n","}\n","\n",".xr-section-inline-details {\n","  grid-column: 2 / -1;\n","}\n","\n",".xr-section-details {\n","  display: none;\n","  grid-column: 1 / -1;\n","  margin-bottom: 5px;\n","}\n","\n",".xr-section-summary-in:checked ~ .xr-section-details {\n","  display: contents;\n","}\n","\n",".xr-array-wrap {\n","  grid-column: 1 / -1;\n","  display: grid;\n","  grid-template-columns: 20px auto;\n","}\n","\n",".xr-array-wrap > label {\n","  grid-column: 1;\n","  vertical-align: top;\n","}\n","\n",".xr-preview {\n","  color: var(--xr-font-color3);\n","}\n","\n",".xr-array-preview,\n",".xr-array-data {\n","  padding: 0 5px !important;\n","  grid-column: 2;\n","}\n","\n",".xr-array-data,\n",".xr-array-in:checked ~ .xr-array-preview {\n","  display: none;\n","}\n","\n",".xr-array-in:checked ~ .xr-array-data,\n",".xr-array-preview {\n","  display: inline-block;\n","}\n","\n",".xr-dim-list {\n","  display: inline-block !important;\n","  list-style: none;\n","  padding: 0 !important;\n","  margin: 0;\n","}\n","\n",".xr-dim-list li {\n","  display: inline-block;\n","  padding: 0;\n","  margin: 0;\n","}\n","\n",".xr-dim-list:before {\n","  content: '(';\n","}\n","\n",".xr-dim-list:after {\n","  content: ')';\n","}\n","\n",".xr-dim-list li:not(:last-child):after {\n","  content: ',';\n","  padding-right: 5px;\n","}\n","\n",".xr-has-index {\n","  font-weight: bold;\n","}\n","\n",".xr-var-list,\n",".xr-var-item {\n","  display: contents;\n","}\n","\n",".xr-var-item > div,\n",".xr-var-item label,\n",".xr-var-item > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-even);\n","  margin-bottom: 0;\n","}\n","\n",".xr-var-item > .xr-var-name:hover span {\n","  padding-right: 5px;\n","}\n","\n",".xr-var-list > li:nth-child(odd) > div,\n",".xr-var-list > li:nth-child(odd) > label,\n",".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-odd);\n","}\n","\n",".xr-var-name {\n","  grid-column: 1;\n","}\n","\n",".xr-var-dims {\n","  grid-column: 2;\n","}\n","\n",".xr-var-dtype {\n","  grid-column: 3;\n","  text-align: right;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-preview {\n","  grid-column: 4;\n","}\n","\n",".xr-index-preview {\n","  grid-column: 2 / 5;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-name,\n",".xr-var-dims,\n",".xr-var-dtype,\n",".xr-preview,\n",".xr-attrs dt {\n","  white-space: nowrap;\n","  overflow: hidden;\n","  text-overflow: ellipsis;\n","  padding-right: 10px;\n","}\n","\n",".xr-var-name:hover,\n",".xr-var-dims:hover,\n",".xr-var-dtype:hover,\n",".xr-attrs dt:hover {\n","  overflow: visible;\n","  width: auto;\n","  z-index: 1;\n","}\n","\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  display: none;\n","  background-color: var(--xr-background-color) !important;\n","  padding-bottom: 5px !important;\n","}\n","\n",".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",".xr-var-data-in:checked ~ .xr-var-data,\n",".xr-index-data-in:checked ~ .xr-index-data {\n","  display: block;\n","}\n","\n",".xr-var-data > table {\n","  float: right;\n","}\n","\n",".xr-var-name span,\n",".xr-var-data,\n",".xr-index-name div,\n",".xr-index-data,\n",".xr-attrs {\n","  padding-left: 25px !important;\n","}\n","\n",".xr-attrs,\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  grid-column: 1 / -1;\n","}\n","\n","dl.xr-attrs {\n","  padding: 0;\n","  margin: 0;\n","  display: grid;\n","  grid-template-columns: 125px auto;\n","}\n","\n",".xr-attrs dt,\n",".xr-attrs dd {\n","  padding: 0;\n","  margin: 0;\n","  float: left;\n","  padding-right: 10px;\n","  width: auto;\n","}\n","\n",".xr-attrs dt {\n","  font-weight: normal;\n","  grid-column: 1;\n","}\n","\n",".xr-attrs dt:hover span {\n","  display: inline-block;\n","  background: var(--xr-background-color);\n","  padding-right: 10px;\n","}\n","\n",".xr-attrs dd {\n","  grid-column: 2;\n","  white-space: pre-wrap;\n","  word-break: break-all;\n","}\n","\n",".xr-icon-database,\n",".xr-icon-file-text2,\n",".xr-no-icon {\n","  display: inline-block;\n","  vertical-align: middle;\n","  width: 1em;\n","  height: 1.5em !important;\n","  stroke-width: 0;\n","  stroke: currentColor;\n","  fill: currentColor;\n","}\n","</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt;\n","Dimensions:   (chain: 1, draw: 5000)\n","Coordinates:\n","  * chain     (chain) int64 0\n","  * draw      (draw) int64 0 1 2 3 4 5 6 ... 4993 4994 4995 4996 4997 4998 4999\n","Data variables:\n","    mu_prior  (chain, draw) float64 326.3 308.7 308.7 ... 302.8 295.2 303.9\n","Attributes:\n","    created_at:                 2024-10-14T02:22:18.255920+00:00\n","    arviz_version:              0.19.0\n","    inference_library:          pymc\n","    inference_library_version:  5.17.0\n","    sampling_time:              0.9197731018066406\n","    tuning_steps:               1000</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-83d695a2-ecca-41fe-a5ef-0c0738cf2144' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-83d695a2-ecca-41fe-a5ef-0c0738cf2144' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>chain</span>: 1</li><li><span class='xr-has-index'>draw</span>: 5000</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-a8def6ac-d768-47ed-b778-7d0d1d9c37cb' class='xr-section-summary-in' type='checkbox'  checked><label for='section-a8def6ac-d768-47ed-b778-7d0d1d9c37cb' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>chain</span></div><div class='xr-var-dims'>(chain)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0</div><input id='attrs-20fd0c2a-c40f-40d5-8179-3bc989c7825e' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-20fd0c2a-c40f-40d5-8179-3bc989c7825e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-771dfd3a-8a70-4fd6-b680-9fd450121cf5' class='xr-var-data-in' type='checkbox'><label for='data-771dfd3a-8a70-4fd6-b680-9fd450121cf5' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>draw</span></div><div class='xr-var-dims'>(draw)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 ... 4996 4997 4998 4999</div><input id='attrs-cc1dabec-f208-4459-80d8-bfa87f84562c' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-cc1dabec-f208-4459-80d8-bfa87f84562c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-0ee30fec-1012-4283-8b43-55f26f484d17' class='xr-var-data-in' type='checkbox'><label for='data-0ee30fec-1012-4283-8b43-55f26f484d17' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([   0,    1,    2, ..., 4997, 4998, 4999])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-c6766bfc-c9c2-4dc2-ba14-e0ae78529549' class='xr-section-summary-in' type='checkbox'  checked><label for='section-c6766bfc-c9c2-4dc2-ba14-e0ae78529549' class='xr-section-summary' >Data variables: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>mu_prior</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>326.3 308.7 308.7 ... 295.2 303.9</div><input id='attrs-c9b38a4c-df9f-44c8-b154-a9870aaae402' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-c9b38a4c-df9f-44c8-b154-a9870aaae402' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-e803da8a-8b7f-43a3-9321-ffc4acf36401' class='xr-var-data-in' type='checkbox'><label for='data-e803da8a-8b7f-43a3-9321-ffc4acf36401' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[326.26582574, 308.73911216, 308.73911216, ..., 302.75568666,\n","        295.21476448, 303.90854392]])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-04985284-feb9-4ed1-9bc3-30bf8ba0e820' class='xr-section-summary-in' type='checkbox'  ><label for='section-04985284-feb9-4ed1-9bc3-30bf8ba0e820' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>chain</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-83a3d1b2-5570-48f2-bf1e-ebbeabb02f1c' class='xr-index-data-in' type='checkbox'/><label for='index-83a3d1b2-5570-48f2-bf1e-ebbeabb02f1c' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0], dtype=&#x27;int64&#x27;, name=&#x27;chain&#x27;))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>draw</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-7461c24c-09e3-4c5b-b271-7d1daf549655' class='xr-index-data-in' type='checkbox'/><label for='index-7461c24c-09e3-4c5b-b271-7d1daf549655' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,\n","       ...\n","       4990, 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, 4999],\n","      dtype=&#x27;int64&#x27;, name=&#x27;draw&#x27;, length=5000))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-5a143b2f-4613-4984-9893-36433640b0a4' class='xr-section-summary-in' type='checkbox'  checked><label for='section-5a143b2f-4613-4984-9893-36433640b0a4' class='xr-section-summary' >Attributes: <span>(6)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>created_at :</span></dt><dd>2024-10-14T02:22:18.255920+00:00</dd><dt><span>arviz_version :</span></dt><dd>0.19.0</dd><dt><span>inference_library :</span></dt><dd>pymc</dd><dt><span>inference_library_version :</span></dt><dd>5.17.0</dd><dt><span>sampling_time :</span></dt><dd>0.9197731018066406</dd><dt><span>tuning_steps :</span></dt><dd>1000</dd></dl></div></li></ul></div></div><br></div>\n","                      </ul>\n","                  </div>\n","            </li>\n","            \n","            <li class = \"xr-section-item\">\n","                  <input id=\"idata_sample_stats31665bc1-701a-4797-94f6-d2e3e8230130\" class=\"xr-section-summary-in\" type=\"checkbox\">\n","                  <label for=\"idata_sample_stats31665bc1-701a-4797-94f6-d2e3e8230130\" class = \"xr-section-summary\">sample_stats</label>\n","                  <div class=\"xr-section-inline-details\"></div>\n","                  <div class=\"xr-section-details\">\n","                      <ul id=\"xr-dataset-coord-list\" class=\"xr-var-list\">\n","                          <div style=\"padding-left:2rem;\"><div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n","<defs>\n","<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n","<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n","<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","</symbol>\n","<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n","<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n","<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","</symbol>\n","</defs>\n","</svg>\n","<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n"," *\n"," */\n","\n",":root {\n","  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n","  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n","  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n","  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n","  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n","  --xr-background-color: var(--jp-layout-color0, white);\n","  --xr-background-color-row-even: var(--jp-layout-color1, white);\n","  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n","}\n","\n","html[theme=dark],\n","body[data-theme=dark],\n","body.vscode-dark {\n","  --xr-font-color0: rgba(255, 255, 255, 1);\n","  --xr-font-color2: rgba(255, 255, 255, 0.54);\n","  --xr-font-color3: rgba(255, 255, 255, 0.38);\n","  --xr-border-color: #1F1F1F;\n","  --xr-disabled-color: #515151;\n","  --xr-background-color: #111111;\n","  --xr-background-color-row-even: #111111;\n","  --xr-background-color-row-odd: #313131;\n","}\n","\n",".xr-wrap {\n","  display: block !important;\n","  min-width: 300px;\n","  max-width: 700px;\n","}\n","\n",".xr-text-repr-fallback {\n","  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n","  display: none;\n","}\n","\n",".xr-header {\n","  padding-top: 6px;\n","  padding-bottom: 6px;\n","  margin-bottom: 4px;\n","  border-bottom: solid 1px var(--xr-border-color);\n","}\n","\n",".xr-header > div,\n",".xr-header > ul {\n","  display: inline;\n","  margin-top: 0;\n","  margin-bottom: 0;\n","}\n","\n",".xr-obj-type,\n",".xr-array-name {\n","  margin-left: 2px;\n","  margin-right: 10px;\n","}\n","\n",".xr-obj-type {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-sections {\n","  padding-left: 0 !important;\n","  display: grid;\n","  grid-template-columns: 150px auto auto 1fr 20px 20px;\n","}\n","\n",".xr-section-item {\n","  display: contents;\n","}\n","\n",".xr-section-item input {\n","  display: none;\n","}\n","\n",".xr-section-item input + label {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-item input:enabled + label {\n","  cursor: pointer;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-item input:enabled + label:hover {\n","  color: var(--xr-font-color0);\n","}\n","\n",".xr-section-summary {\n","  grid-column: 1;\n","  color: var(--xr-font-color2);\n","  font-weight: 500;\n","}\n","\n",".xr-section-summary > span {\n","  display: inline-block;\n","  padding-left: 0.5em;\n","}\n","\n",".xr-section-summary-in:disabled + label {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-summary-in + label:before {\n","  display: inline-block;\n","  content: '►';\n","  font-size: 11px;\n","  width: 15px;\n","  text-align: center;\n","}\n","\n",".xr-section-summary-in:disabled + label:before {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-summary-in:checked + label:before {\n","  content: '▼';\n","}\n","\n",".xr-section-summary-in:checked + label > span {\n","  display: none;\n","}\n","\n",".xr-section-summary,\n",".xr-section-inline-details {\n","  padding-top: 4px;\n","  padding-bottom: 4px;\n","}\n","\n",".xr-section-inline-details {\n","  grid-column: 2 / -1;\n","}\n","\n",".xr-section-details {\n","  display: none;\n","  grid-column: 1 / -1;\n","  margin-bottom: 5px;\n","}\n","\n",".xr-section-summary-in:checked ~ .xr-section-details {\n","  display: contents;\n","}\n","\n",".xr-array-wrap {\n","  grid-column: 1 / -1;\n","  display: grid;\n","  grid-template-columns: 20px auto;\n","}\n","\n",".xr-array-wrap > label {\n","  grid-column: 1;\n","  vertical-align: top;\n","}\n","\n",".xr-preview {\n","  color: var(--xr-font-color3);\n","}\n","\n",".xr-array-preview,\n",".xr-array-data {\n","  padding: 0 5px !important;\n","  grid-column: 2;\n","}\n","\n",".xr-array-data,\n",".xr-array-in:checked ~ .xr-array-preview {\n","  display: none;\n","}\n","\n",".xr-array-in:checked ~ .xr-array-data,\n",".xr-array-preview {\n","  display: inline-block;\n","}\n","\n",".xr-dim-list {\n","  display: inline-block !important;\n","  list-style: none;\n","  padding: 0 !important;\n","  margin: 0;\n","}\n","\n",".xr-dim-list li {\n","  display: inline-block;\n","  padding: 0;\n","  margin: 0;\n","}\n","\n",".xr-dim-list:before {\n","  content: '(';\n","}\n","\n",".xr-dim-list:after {\n","  content: ')';\n","}\n","\n",".xr-dim-list li:not(:last-child):after {\n","  content: ',';\n","  padding-right: 5px;\n","}\n","\n",".xr-has-index {\n","  font-weight: bold;\n","}\n","\n",".xr-var-list,\n",".xr-var-item {\n","  display: contents;\n","}\n","\n",".xr-var-item > div,\n",".xr-var-item label,\n",".xr-var-item > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-even);\n","  margin-bottom: 0;\n","}\n","\n",".xr-var-item > .xr-var-name:hover span {\n","  padding-right: 5px;\n","}\n","\n",".xr-var-list > li:nth-child(odd) > div,\n",".xr-var-list > li:nth-child(odd) > label,\n",".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-odd);\n","}\n","\n",".xr-var-name {\n","  grid-column: 1;\n","}\n","\n",".xr-var-dims {\n","  grid-column: 2;\n","}\n","\n",".xr-var-dtype {\n","  grid-column: 3;\n","  text-align: right;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-preview {\n","  grid-column: 4;\n","}\n","\n",".xr-index-preview {\n","  grid-column: 2 / 5;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-name,\n",".xr-var-dims,\n",".xr-var-dtype,\n",".xr-preview,\n",".xr-attrs dt {\n","  white-space: nowrap;\n","  overflow: hidden;\n","  text-overflow: ellipsis;\n","  padding-right: 10px;\n","}\n","\n",".xr-var-name:hover,\n",".xr-var-dims:hover,\n",".xr-var-dtype:hover,\n",".xr-attrs dt:hover {\n","  overflow: visible;\n","  width: auto;\n","  z-index: 1;\n","}\n","\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  display: none;\n","  background-color: var(--xr-background-color) !important;\n","  padding-bottom: 5px !important;\n","}\n","\n",".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",".xr-var-data-in:checked ~ .xr-var-data,\n",".xr-index-data-in:checked ~ .xr-index-data {\n","  display: block;\n","}\n","\n",".xr-var-data > table {\n","  float: right;\n","}\n","\n",".xr-var-name span,\n",".xr-var-data,\n",".xr-index-name div,\n",".xr-index-data,\n",".xr-attrs {\n","  padding-left: 25px !important;\n","}\n","\n",".xr-attrs,\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  grid-column: 1 / -1;\n","}\n","\n","dl.xr-attrs {\n","  padding: 0;\n","  margin: 0;\n","  display: grid;\n","  grid-template-columns: 125px auto;\n","}\n","\n",".xr-attrs dt,\n",".xr-attrs dd {\n","  padding: 0;\n","  margin: 0;\n","  float: left;\n","  padding-right: 10px;\n","  width: auto;\n","}\n","\n",".xr-attrs dt {\n","  font-weight: normal;\n","  grid-column: 1;\n","}\n","\n",".xr-attrs dt:hover span {\n","  display: inline-block;\n","  background: var(--xr-background-color);\n","  padding-right: 10px;\n","}\n","\n",".xr-attrs dd {\n","  grid-column: 2;\n","  white-space: pre-wrap;\n","  word-break: break-all;\n","}\n","\n",".xr-icon-database,\n",".xr-icon-file-text2,\n",".xr-no-icon {\n","  display: inline-block;\n","  vertical-align: middle;\n","  width: 1em;\n","  height: 1.5em !important;\n","  stroke-width: 0;\n","  stroke: currentColor;\n","  fill: currentColor;\n","}\n","</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt;\n","Dimensions:                (chain: 1, draw: 5000)\n","Coordinates:\n","  * chain                  (chain) int64 0\n","  * draw                   (draw) int64 0 1 2 3 4 5 ... 4995 4996 4997 4998 4999\n","Data variables: (12/17)\n","    acceptance_rate        (chain, draw) float64 0.5652 1.0 ... 0.5689 1.0\n","    diverging              (chain, draw) bool False False False ... False False\n","    energy                 (chain, draw) float64 28.89 27.74 ... 28.47 27.81\n","    energy_error           (chain, draw) float64 0.8018 -0.9568 ... -0.6153\n","    index_in_trajectory    (chain, draw) int64 1 -1 0 -1 0 0 ... -1 1 -1 -1 1 -1\n","    largest_eigval         (chain, draw) float64 nan nan nan nan ... nan nan nan\n","    ...                     ...\n","    process_time_diff      (chain, draw) float64 0.000113 8.7e-05 ... 9.1e-05\n","    reached_max_treedepth  (chain, draw) bool False False False ... False False\n","    smallest_eigval        (chain, draw) float64 nan nan nan nan ... nan nan nan\n","    step_size              (chain, draw) float64 1.603 1.603 ... 1.603 1.603\n","    step_size_bar          (chain, draw) float64 1.338 1.338 ... 1.338 1.338\n","    tree_depth             (chain, draw) int64 2 1 1 1 1 1 2 2 ... 2 1 1 1 1 1 1\n","Attributes:\n","    created_at:                 2024-10-14T02:22:18.262637+00:00\n","    arviz_version:              0.19.0\n","    inference_library:          pymc\n","    inference_library_version:  5.17.0\n","    sampling_time:              0.9197731018066406\n","    tuning_steps:               1000</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-6a00c04f-84bf-4896-b910-dd5b954d6886' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-6a00c04f-84bf-4896-b910-dd5b954d6886' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>chain</span>: 1</li><li><span class='xr-has-index'>draw</span>: 5000</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-12f2b2b7-c887-4aa3-9c71-2abf15ddf934' class='xr-section-summary-in' type='checkbox'  checked><label for='section-12f2b2b7-c887-4aa3-9c71-2abf15ddf934' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>chain</span></div><div class='xr-var-dims'>(chain)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0</div><input id='attrs-cf324bcc-f186-464a-b3bf-e06453def3b4' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-cf324bcc-f186-464a-b3bf-e06453def3b4' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-2621e2db-dd88-447d-858c-4207b85a3e98' class='xr-var-data-in' type='checkbox'><label for='data-2621e2db-dd88-447d-858c-4207b85a3e98' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>draw</span></div><div class='xr-var-dims'>(draw)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0 1 2 3 4 ... 4996 4997 4998 4999</div><input id='attrs-82cc5f24-50b2-4cc8-b399-b28dcc88b02a' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-82cc5f24-50b2-4cc8-b399-b28dcc88b02a' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-4ad008ed-f9a2-4cad-bf69-189f33ec614e' class='xr-var-data-in' type='checkbox'><label for='data-4ad008ed-f9a2-4cad-bf69-189f33ec614e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([   0,    1,    2, ..., 4997, 4998, 4999])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-24737c32-3327-432b-a262-f11441bd003c' class='xr-section-summary-in' type='checkbox'  ><label for='section-24737c32-3327-432b-a262-f11441bd003c' class='xr-section-summary' >Data variables: <span>(17)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>acceptance_rate</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.5652 1.0 0.09468 ... 0.5689 1.0</div><input id='attrs-4f0dd916-869c-4eff-90f8-c2248911dc03' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-4f0dd916-869c-4eff-90f8-c2248911dc03' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-72212226-3c7f-4656-8671-6b44bc2370e8' class='xr-var-data-in' type='checkbox'><label for='data-72212226-3c7f-4656-8671-6b44bc2370e8' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[0.56522152, 1.        , 0.094679  , ..., 1.        , 0.56888785,\n","        1.        ]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>diverging</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>bool</div><div class='xr-var-preview xr-preview'>False False False ... False False</div><input id='attrs-d2930d52-31a4-4d06-8fe0-4fb1c9d830ed' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-d2930d52-31a4-4d06-8fe0-4fb1c9d830ed' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9e2dd4f5-c67a-4007-bdc3-e89da5c782c8' class='xr-var-data-in' type='checkbox'><label for='data-9e2dd4f5-c67a-4007-bdc3-e89da5c782c8' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[False, False, False, ..., False, False, False]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>energy</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>28.89 27.74 28.93 ... 28.47 27.81</div><input id='attrs-27772bf0-ce04-43fa-9341-5bd74e2bca7c' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-27772bf0-ce04-43fa-9341-5bd74e2bca7c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-efb02ea6-19c6-4dc4-9352-2f0edd3a6a8e' class='xr-var-data-in' type='checkbox'><label for='data-efb02ea6-19c6-4dc4-9352-2f0edd3a6a8e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[28.89167245, 27.73963773, 28.92839744, ..., 27.64194037,\n","        28.47245732, 27.80524676]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>energy_error</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.8018 -0.9568 ... 0.5641 -0.6153</div><input id='attrs-044772a1-afe3-43cd-b161-72dd4b7a50a9' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-044772a1-afe3-43cd-b161-72dd4b7a50a9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-302aec85-374e-4f6a-9531-32911a68757e' class='xr-var-data-in' type='checkbox'><label for='data-302aec85-374e-4f6a-9531-32911a68757e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[ 0.80183807, -0.95681679,  0.        , ..., -0.26485964,\n","         0.56407197, -0.61528949]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>index_in_trajectory</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>1 -1 0 -1 0 0 ... -1 1 -1 -1 1 -1</div><input id='attrs-a3dee9af-f013-41a8-a37c-744b50a44d16' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-a3dee9af-f013-41a8-a37c-744b50a44d16' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-51913428-9c36-4af5-ac0e-29e5b1b8f312' class='xr-var-data-in' type='checkbox'><label for='data-51913428-9c36-4af5-ac0e-29e5b1b8f312' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[ 1, -1,  0, ..., -1,  1, -1]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>largest_eigval</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>nan nan nan nan ... nan nan nan nan</div><input id='attrs-47b65139-8007-4f00-b433-fca2913a8949' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-47b65139-8007-4f00-b433-fca2913a8949' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7bf41509-e04e-40eb-8638-941fd25600a7' class='xr-var-data-in' type='checkbox'><label for='data-7bf41509-e04e-40eb-8638-941fd25600a7' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[nan, nan, nan, ..., nan, nan, nan]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lp</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>-28.7 -26.93 ... -28.28 -27.14</div><input id='attrs-8961af81-395c-4c4c-bda9-9313e576d1ef' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-8961af81-395c-4c4c-bda9-9313e576d1ef' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-cee2cc04-b82c-45a0-9d7a-7f5b5b615657' class='xr-var-data-in' type='checkbox'><label for='data-cee2cc04-b82c-45a0-9d7a-7f5b5b615657' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[-28.69590132, -26.92952671, -26.92952671, ..., -27.23383504,\n","        -28.27516543, -27.13928263]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>max_energy_error</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.9362 -0.9568 ... 0.5641 -0.6153</div><input id='attrs-26f92c61-9de6-4369-952a-6c5475e04d74' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-26f92c61-9de6-4369-952a-6c5475e04d74' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-4a27cdaa-0095-459d-a7af-40170f8ad7ae' class='xr-var-data-in' type='checkbox'><label for='data-4a27cdaa-0095-459d-a7af-40170f8ad7ae' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[ 0.93616344, -0.95681679,  2.35726308, ..., -0.26485964,\n","         0.56407197, -0.61528949]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>n_steps</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>3.0 1.0 1.0 1.0 ... 1.0 1.0 1.0 1.0</div><input id='attrs-cccb6ca2-2c4b-4e96-a773-bde8d25bb049' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-cccb6ca2-2c4b-4e96-a773-bde8d25bb049' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9488e78a-3e3f-4731-90cc-246b48793759' class='xr-var-data-in' type='checkbox'><label for='data-9488e78a-3e3f-4731-90cc-246b48793759' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[3., 1., 1., ..., 1., 1., 1.]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>perf_counter_diff</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.0001112 7.075e-05 ... 7.733e-05</div><input id='attrs-2c4fa1e4-ff08-4e49-9cd5-c339eb01c85c' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-2c4fa1e4-ff08-4e49-9cd5-c339eb01c85c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-9dc8c252-d743-4ab6-aaeb-a4b1f8fc2259' class='xr-var-data-in' type='checkbox'><label for='data-9dc8c252-d743-4ab6-aaeb-a4b1f8fc2259' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[1.11208006e-04, 7.07500149e-05, 6.32500160e-05, ...,\n","        6.85409759e-05, 7.30829779e-05, 7.73339998e-05]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>perf_counter_start</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>3.924e+05 3.924e+05 ... 3.924e+05</div><input id='attrs-00d88dd0-e20b-4e79-aebf-0bc56d61280f' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-00d88dd0-e20b-4e79-aebf-0bc56d61280f' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7c45c126-e827-4c79-abbc-0de4c3f8363e' class='xr-var-data-in' type='checkbox'><label for='data-7c45c126-e827-4c79-abbc-0de4c3f8363e' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[392389.81603375, 392389.81616675, 392389.81626033, ...,\n","        392390.54765   , 392390.54773788, 392390.54782979]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>process_time_diff</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>0.000113 8.7e-05 ... 9.1e-05</div><input id='attrs-c7459025-cea2-4a86-a4f5-54886e52f958' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-c7459025-cea2-4a86-a4f5-54886e52f958' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-2687c086-339a-48ad-92ea-d507e149a745' class='xr-var-data-in' type='checkbox'><label for='data-2687c086-339a-48ad-92ea-d507e149a745' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[1.13e-04, 8.70e-05, 7.80e-05, ..., 8.40e-05, 8.40e-05, 9.10e-05]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>reached_max_treedepth</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>bool</div><div class='xr-var-preview xr-preview'>False False False ... False False</div><input id='attrs-04a407f3-3a1d-4fc6-99aa-d87b7cbe1aa9' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-04a407f3-3a1d-4fc6-99aa-d87b7cbe1aa9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5ab18697-cdba-406e-83fb-63da85677aeb' class='xr-var-data-in' type='checkbox'><label for='data-5ab18697-cdba-406e-83fb-63da85677aeb' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[False, False, False, ..., False, False, False]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>smallest_eigval</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>nan nan nan nan ... nan nan nan nan</div><input id='attrs-0cb5190f-dd1f-43c0-bd54-daadee72db51' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-0cb5190f-dd1f-43c0-bd54-daadee72db51' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-0f30bcd6-b0eb-4308-bb8d-5428bc322841' class='xr-var-data-in' type='checkbox'><label for='data-0f30bcd6-b0eb-4308-bb8d-5428bc322841' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[nan, nan, nan, ..., nan, nan, nan]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>step_size</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>1.603 1.603 1.603 ... 1.603 1.603</div><input id='attrs-7f034a11-30f5-4465-9edf-a746a69d9bf3' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-7f034a11-30f5-4465-9edf-a746a69d9bf3' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-b1c43904-d61c-4b83-be98-01f24a4e31c3' class='xr-var-data-in' type='checkbox'><label for='data-b1c43904-d61c-4b83-be98-01f24a4e31c3' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[1.60301898, 1.60301898, 1.60301898, ..., 1.60301898, 1.60301898,\n","        1.60301898]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>step_size_bar</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>1.338 1.338 1.338 ... 1.338 1.338</div><input id='attrs-c2374da3-c8d4-47bd-b6b2-dd4cd7114329' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-c2374da3-c8d4-47bd-b6b2-dd4cd7114329' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-a1e21e6d-2604-4864-aecc-9097edc53b6a' class='xr-var-data-in' type='checkbox'><label for='data-a1e21e6d-2604-4864-aecc-9097edc53b6a' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[1.33769152, 1.33769152, 1.33769152, ..., 1.33769152, 1.33769152,\n","        1.33769152]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>tree_depth</span></div><div class='xr-var-dims'>(chain, draw)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>2 1 1 1 1 1 2 2 ... 2 2 1 1 1 1 1 1</div><input id='attrs-0d0b6412-97ee-4751-aeca-cb0850e868b7' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-0d0b6412-97ee-4751-aeca-cb0850e868b7' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-d1173480-0952-4749-b9ea-40b262f907cc' class='xr-var-data-in' type='checkbox'><label for='data-d1173480-0952-4749-b9ea-40b262f907cc' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[2, 1, 1, ..., 1, 1, 1]])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-3d9480b2-7fbe-459b-8d1b-438a8ea1c4a0' class='xr-section-summary-in' type='checkbox'  ><label for='section-3d9480b2-7fbe-459b-8d1b-438a8ea1c4a0' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>chain</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-39c29554-2725-4a9a-9104-7144a353d241' class='xr-index-data-in' type='checkbox'/><label for='index-39c29554-2725-4a9a-9104-7144a353d241' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0], dtype=&#x27;int64&#x27;, name=&#x27;chain&#x27;))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>draw</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-40347348-0c55-4d18-b49d-d6f02c60b7a8' class='xr-index-data-in' type='checkbox'/><label for='index-40347348-0c55-4d18-b49d-d6f02c60b7a8' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,\n","       ...\n","       4990, 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, 4999],\n","      dtype=&#x27;int64&#x27;, name=&#x27;draw&#x27;, length=5000))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-7d165f30-86f8-4b28-84b5-49d99e50165b' class='xr-section-summary-in' type='checkbox'  checked><label for='section-7d165f30-86f8-4b28-84b5-49d99e50165b' class='xr-section-summary' >Attributes: <span>(6)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>created_at :</span></dt><dd>2024-10-14T02:22:18.262637+00:00</dd><dt><span>arviz_version :</span></dt><dd>0.19.0</dd><dt><span>inference_library :</span></dt><dd>pymc</dd><dt><span>inference_library_version :</span></dt><dd>5.17.0</dd><dt><span>sampling_time :</span></dt><dd>0.9197731018066406</dd><dt><span>tuning_steps :</span></dt><dd>1000</dd></dl></div></li></ul></div></div><br></div>\n","                      </ul>\n","                  </div>\n","            </li>\n","            \n","            <li class = \"xr-section-item\">\n","                  <input id=\"idata_observed_databf583edb-baa9-4c59-a51c-931673952763\" class=\"xr-section-summary-in\" type=\"checkbox\">\n","                  <label for=\"idata_observed_databf583edb-baa9-4c59-a51c-931673952763\" class = \"xr-section-summary\">observed_data</label>\n","                  <div class=\"xr-section-inline-details\"></div>\n","                  <div class=\"xr-section-details\">\n","                      <ul id=\"xr-dataset-coord-list\" class=\"xr-var-list\">\n","                          <div style=\"padding-left:2rem;\"><div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n","<defs>\n","<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n","<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n","<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n","</symbol>\n","<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n","<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n","<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n","</symbol>\n","</defs>\n","</svg>\n","<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n"," *\n"," */\n","\n",":root {\n","  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n","  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n","  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n","  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n","  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n","  --xr-background-color: var(--jp-layout-color0, white);\n","  --xr-background-color-row-even: var(--jp-layout-color1, white);\n","  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n","}\n","\n","html[theme=dark],\n","body[data-theme=dark],\n","body.vscode-dark {\n","  --xr-font-color0: rgba(255, 255, 255, 1);\n","  --xr-font-color2: rgba(255, 255, 255, 0.54);\n","  --xr-font-color3: rgba(255, 255, 255, 0.38);\n","  --xr-border-color: #1F1F1F;\n","  --xr-disabled-color: #515151;\n","  --xr-background-color: #111111;\n","  --xr-background-color-row-even: #111111;\n","  --xr-background-color-row-odd: #313131;\n","}\n","\n",".xr-wrap {\n","  display: block !important;\n","  min-width: 300px;\n","  max-width: 700px;\n","}\n","\n",".xr-text-repr-fallback {\n","  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n","  display: none;\n","}\n","\n",".xr-header {\n","  padding-top: 6px;\n","  padding-bottom: 6px;\n","  margin-bottom: 4px;\n","  border-bottom: solid 1px var(--xr-border-color);\n","}\n","\n",".xr-header > div,\n",".xr-header > ul {\n","  display: inline;\n","  margin-top: 0;\n","  margin-bottom: 0;\n","}\n","\n",".xr-obj-type,\n",".xr-array-name {\n","  margin-left: 2px;\n","  margin-right: 10px;\n","}\n","\n",".xr-obj-type {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-sections {\n","  padding-left: 0 !important;\n","  display: grid;\n","  grid-template-columns: 150px auto auto 1fr 20px 20px;\n","}\n","\n",".xr-section-item {\n","  display: contents;\n","}\n","\n",".xr-section-item input {\n","  display: none;\n","}\n","\n",".xr-section-item input + label {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-item input:enabled + label {\n","  cursor: pointer;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-item input:enabled + label:hover {\n","  color: var(--xr-font-color0);\n","}\n","\n",".xr-section-summary {\n","  grid-column: 1;\n","  color: var(--xr-font-color2);\n","  font-weight: 500;\n","}\n","\n",".xr-section-summary > span {\n","  display: inline-block;\n","  padding-left: 0.5em;\n","}\n","\n",".xr-section-summary-in:disabled + label {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-summary-in + label:before {\n","  display: inline-block;\n","  content: '►';\n","  font-size: 11px;\n","  width: 15px;\n","  text-align: center;\n","}\n","\n",".xr-section-summary-in:disabled + label:before {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-summary-in:checked + label:before {\n","  content: '▼';\n","}\n","\n",".xr-section-summary-in:checked + label > span {\n","  display: none;\n","}\n","\n",".xr-section-summary,\n",".xr-section-inline-details {\n","  padding-top: 4px;\n","  padding-bottom: 4px;\n","}\n","\n",".xr-section-inline-details {\n","  grid-column: 2 / -1;\n","}\n","\n",".xr-section-details {\n","  display: none;\n","  grid-column: 1 / -1;\n","  margin-bottom: 5px;\n","}\n","\n",".xr-section-summary-in:checked ~ .xr-section-details {\n","  display: contents;\n","}\n","\n",".xr-array-wrap {\n","  grid-column: 1 / -1;\n","  display: grid;\n","  grid-template-columns: 20px auto;\n","}\n","\n",".xr-array-wrap > label {\n","  grid-column: 1;\n","  vertical-align: top;\n","}\n","\n",".xr-preview {\n","  color: var(--xr-font-color3);\n","}\n","\n",".xr-array-preview,\n",".xr-array-data {\n","  padding: 0 5px !important;\n","  grid-column: 2;\n","}\n","\n",".xr-array-data,\n",".xr-array-in:checked ~ .xr-array-preview {\n","  display: none;\n","}\n","\n",".xr-array-in:checked ~ .xr-array-data,\n",".xr-array-preview {\n","  display: inline-block;\n","}\n","\n",".xr-dim-list {\n","  display: inline-block !important;\n","  list-style: none;\n","  padding: 0 !important;\n","  margin: 0;\n","}\n","\n",".xr-dim-list li {\n","  display: inline-block;\n","  padding: 0;\n","  margin: 0;\n","}\n","\n",".xr-dim-list:before {\n","  content: '(';\n","}\n","\n",".xr-dim-list:after {\n","  content: ')';\n","}\n","\n",".xr-dim-list li:not(:last-child):after {\n","  content: ',';\n","  padding-right: 5px;\n","}\n","\n",".xr-has-index {\n","  font-weight: bold;\n","}\n","\n",".xr-var-list,\n",".xr-var-item {\n","  display: contents;\n","}\n","\n",".xr-var-item > div,\n",".xr-var-item label,\n",".xr-var-item > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-even);\n","  margin-bottom: 0;\n","}\n","\n",".xr-var-item > .xr-var-name:hover span {\n","  padding-right: 5px;\n","}\n","\n",".xr-var-list > li:nth-child(odd) > div,\n",".xr-var-list > li:nth-child(odd) > label,\n",".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-odd);\n","}\n","\n",".xr-var-name {\n","  grid-column: 1;\n","}\n","\n",".xr-var-dims {\n","  grid-column: 2;\n","}\n","\n",".xr-var-dtype {\n","  grid-column: 3;\n","  text-align: right;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-preview {\n","  grid-column: 4;\n","}\n","\n",".xr-index-preview {\n","  grid-column: 2 / 5;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-name,\n",".xr-var-dims,\n",".xr-var-dtype,\n",".xr-preview,\n",".xr-attrs dt {\n","  white-space: nowrap;\n","  overflow: hidden;\n","  text-overflow: ellipsis;\n","  padding-right: 10px;\n","}\n","\n",".xr-var-name:hover,\n",".xr-var-dims:hover,\n",".xr-var-dtype:hover,\n",".xr-attrs dt:hover {\n","  overflow: visible;\n","  width: auto;\n","  z-index: 1;\n","}\n","\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  display: none;\n","  background-color: var(--xr-background-color) !important;\n","  padding-bottom: 5px !important;\n","}\n","\n",".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",".xr-var-data-in:checked ~ .xr-var-data,\n",".xr-index-data-in:checked ~ .xr-index-data {\n","  display: block;\n","}\n","\n",".xr-var-data > table {\n","  float: right;\n","}\n","\n",".xr-var-name span,\n",".xr-var-data,\n",".xr-index-name div,\n",".xr-index-data,\n",".xr-attrs {\n","  padding-left: 25px !important;\n","}\n","\n",".xr-attrs,\n",".xr-var-attrs,\n",".xr-var-data,\n",".xr-index-data {\n","  grid-column: 1 / -1;\n","}\n","\n","dl.xr-attrs {\n","  padding: 0;\n","  margin: 0;\n","  display: grid;\n","  grid-template-columns: 125px auto;\n","}\n","\n",".xr-attrs dt,\n",".xr-attrs dd {\n","  padding: 0;\n","  margin: 0;\n","  float: left;\n","  padding-right: 10px;\n","  width: auto;\n","}\n","\n",".xr-attrs dt {\n","  font-weight: normal;\n","  grid-column: 1;\n","}\n","\n",".xr-attrs dt:hover span {\n","  display: inline-block;\n","  background: var(--xr-background-color);\n","  padding-right: 10px;\n","}\n","\n",".xr-attrs dd {\n","  grid-column: 2;\n","  white-space: pre-wrap;\n","  word-break: break-all;\n","}\n","\n",".xr-icon-database,\n",".xr-icon-file-text2,\n",".xr-no-icon {\n","  display: inline-block;\n","  vertical-align: middle;\n","  width: 1em;\n","  height: 1.5em !important;\n","  stroke-width: 0;\n","  stroke: currentColor;\n","  fill: currentColor;\n","}\n","</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt;\n","Dimensions:      (Y_obs_dim_0: 5)\n","Coordinates:\n","  * Y_obs_dim_0  (Y_obs_dim_0) int64 0 1 2 3 4\n","Data variables:\n","    Y_obs        (Y_obs_dim_0) float64 320.0 310.0 280.0 340.0 300.0\n","Attributes:\n","    created_at:                 2024-10-14T02:22:18.264633+00:00\n","    arviz_version:              0.19.0\n","    inference_library:          pymc\n","    inference_library_version:  5.17.0</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-4797c32b-5a28-4eaa-bab1-819e9d2b63f2' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-4797c32b-5a28-4eaa-bab1-819e9d2b63f2' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>Y_obs_dim_0</span>: 5</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-e7281b17-ab28-45e8-a85c-c6fc4fcc6172' class='xr-section-summary-in' type='checkbox'  checked><label for='section-e7281b17-ab28-45e8-a85c-c6fc4fcc6172' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>Y_obs_dim_0</span></div><div class='xr-var-dims'>(Y_obs_dim_0)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0 1 2 3 4</div><input id='attrs-d8fe2478-7686-4494-acbe-f53a90bf481d' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-d8fe2478-7686-4494-acbe-f53a90bf481d' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-ed66b95c-d74a-4ce3-94ca-de00c5d22cde' class='xr-var-data-in' type='checkbox'><label for='data-ed66b95c-d74a-4ce3-94ca-de00c5d22cde' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0, 1, 2, 3, 4])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-410a65fe-e038-4f93-8331-c85e99e44c60' class='xr-section-summary-in' type='checkbox'  checked><label for='section-410a65fe-e038-4f93-8331-c85e99e44c60' class='xr-section-summary' >Data variables: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>Y_obs</span></div><div class='xr-var-dims'>(Y_obs_dim_0)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>320.0 310.0 280.0 340.0 300.0</div><input id='attrs-296322ff-7697-4803-be48-f212e44a5be4' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-296322ff-7697-4803-be48-f212e44a5be4' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-e26aa0fe-c7e1-4ff5-a8d2-a841a2f14cd9' class='xr-var-data-in' type='checkbox'><label for='data-e26aa0fe-c7e1-4ff5-a8d2-a841a2f14cd9' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([320., 310., 280., 340., 300.])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-4ea3a661-4467-4472-886a-efde45420c8c' class='xr-section-summary-in' type='checkbox'  ><label for='section-4ea3a661-4467-4472-886a-efde45420c8c' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>Y_obs_dim_0</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-d3e5fecd-07a9-454d-8687-002c4f64f8c4' class='xr-index-data-in' type='checkbox'/><label for='index-d3e5fecd-07a9-454d-8687-002c4f64f8c4' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0, 1, 2, 3, 4], dtype=&#x27;int64&#x27;, name=&#x27;Y_obs_dim_0&#x27;))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-9a93d2e2-8b29-4297-a4df-6ae3ba063f69' class='xr-section-summary-in' type='checkbox'  checked><label for='section-9a93d2e2-8b29-4297-a4df-6ae3ba063f69' class='xr-section-summary' >Attributes: <span>(4)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>created_at :</span></dt><dd>2024-10-14T02:22:18.264633+00:00</dd><dt><span>arviz_version :</span></dt><dd>0.19.0</dd><dt><span>inference_library :</span></dt><dd>pymc</dd><dt><span>inference_library_version :</span></dt><dd>5.17.0</dd></dl></div></li></ul></div></div><br></div>\n","                      </ul>\n","                  </div>\n","            </li>\n","            \n","              </ul>\n","            </div>\n","            <style> /* CSS stylesheet for displaying InferenceData objects in jupyterlab.\n"," *\n"," */\n","\n",":root {\n","  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n","  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n","  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n","  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n","  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n","  --xr-background-color: var(--jp-layout-color0, white);\n","  --xr-background-color-row-even: var(--jp-layout-color1, white);\n","  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n","}\n","\n","html[theme=dark],\n","body.vscode-dark {\n","  --xr-font-color0: rgba(255, 255, 255, 1);\n","  --xr-font-color2: rgba(255, 255, 255, 0.54);\n","  --xr-font-color3: rgba(255, 255, 255, 0.38);\n","  --xr-border-color: #1F1F1F;\n","  --xr-disabled-color: #515151;\n","  --xr-background-color: #111111;\n","  --xr-background-color-row-even: #111111;\n","  --xr-background-color-row-odd: #313131;\n","}\n","\n",".xr-wrap {\n","  display: block;\n","  min-width: 300px;\n","  max-width: 700px;\n","}\n","\n",".xr-text-repr-fallback {\n","  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n","  display: none;\n","}\n","\n",".xr-header {\n","  padding-top: 6px;\n","  padding-bottom: 6px;\n","  margin-bottom: 4px;\n","  border-bottom: solid 1px var(--xr-border-color);\n","}\n","\n",".xr-header > div,\n",".xr-header > ul {\n","  display: inline;\n","  margin-top: 0;\n","  margin-bottom: 0;\n","}\n","\n",".xr-obj-type,\n",".xr-array-name {\n","  margin-left: 2px;\n","  margin-right: 10px;\n","}\n","\n",".xr-obj-type {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-sections {\n","  padding-left: 0 !important;\n","  display: grid;\n","  grid-template-columns: 150px auto auto 1fr 20px 20px;\n","}\n","\n",".xr-sections.group-sections {\n","  grid-template-columns: auto;\n","}\n","\n",".xr-section-item {\n","  display: contents;\n","}\n","\n",".xr-section-item input {\n","  display: none;\n","}\n","\n",".xr-section-item input + label {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-item input:enabled + label {\n","  cursor: pointer;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-item input:enabled + label:hover {\n","  color: var(--xr-font-color0);\n","}\n","\n",".xr-section-summary {\n","  grid-column: 1;\n","  color: var(--xr-font-color2);\n","  font-weight: 500;\n","}\n","\n",".xr-section-summary > span {\n","  display: inline-block;\n","  padding-left: 0.5em;\n","}\n","\n",".xr-section-summary-in:disabled + label {\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-section-summary-in + label:before {\n","  display: inline-block;\n","  content: '►';\n","  font-size: 11px;\n","  width: 15px;\n","  text-align: center;\n","}\n","\n",".xr-section-summary-in:disabled + label:before {\n","  color: var(--xr-disabled-color);\n","}\n","\n",".xr-section-summary-in:checked + label:before {\n","  content: '▼';\n","}\n","\n",".xr-section-summary-in:checked + label > span {\n","  display: none;\n","}\n","\n",".xr-section-summary,\n",".xr-section-inline-details {\n","  padding-top: 4px;\n","  padding-bottom: 4px;\n","}\n","\n",".xr-section-inline-details {\n","  grid-column: 2 / -1;\n","}\n","\n",".xr-section-details {\n","  display: none;\n","  grid-column: 1 / -1;\n","  margin-bottom: 5px;\n","}\n","\n",".xr-section-summary-in:checked ~ .xr-section-details {\n","  display: contents;\n","}\n","\n",".xr-array-wrap {\n","  grid-column: 1 / -1;\n","  display: grid;\n","  grid-template-columns: 20px auto;\n","}\n","\n",".xr-array-wrap > label {\n","  grid-column: 1;\n","  vertical-align: top;\n","}\n","\n",".xr-preview {\n","  color: var(--xr-font-color3);\n","}\n","\n",".xr-array-preview,\n",".xr-array-data {\n","  padding: 0 5px !important;\n","  grid-column: 2;\n","}\n","\n",".xr-array-data,\n",".xr-array-in:checked ~ .xr-array-preview {\n","  display: none;\n","}\n","\n",".xr-array-in:checked ~ .xr-array-data,\n",".xr-array-preview {\n","  display: inline-block;\n","}\n","\n",".xr-dim-list {\n","  display: inline-block !important;\n","  list-style: none;\n","  padding: 0 !important;\n","  margin: 0;\n","}\n","\n",".xr-dim-list li {\n","  display: inline-block;\n","  padding: 0;\n","  margin: 0;\n","}\n","\n",".xr-dim-list:before {\n","  content: '(';\n","}\n","\n",".xr-dim-list:after {\n","  content: ')';\n","}\n","\n",".xr-dim-list li:not(:last-child):after {\n","  content: ',';\n","  padding-right: 5px;\n","}\n","\n",".xr-has-index {\n","  font-weight: bold;\n","}\n","\n",".xr-var-list,\n",".xr-var-item {\n","  display: contents;\n","}\n","\n",".xr-var-item > div,\n",".xr-var-item label,\n",".xr-var-item > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-even);\n","  margin-bottom: 0;\n","}\n","\n",".xr-var-item > .xr-var-name:hover span {\n","  padding-right: 5px;\n","}\n","\n",".xr-var-list > li:nth-child(odd) > div,\n",".xr-var-list > li:nth-child(odd) > label,\n",".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n","  background-color: var(--xr-background-color-row-odd);\n","}\n","\n",".xr-var-name {\n","  grid-column: 1;\n","}\n","\n",".xr-var-dims {\n","  grid-column: 2;\n","}\n","\n",".xr-var-dtype {\n","  grid-column: 3;\n","  text-align: right;\n","  color: var(--xr-font-color2);\n","}\n","\n",".xr-var-preview {\n","  grid-column: 4;\n","}\n","\n",".xr-var-name,\n",".xr-var-dims,\n",".xr-var-dtype,\n",".xr-preview,\n",".xr-attrs dt {\n","  white-space: nowrap;\n","  overflow: hidden;\n","  text-overflow: ellipsis;\n","  padding-right: 10px;\n","}\n","\n",".xr-var-name:hover,\n",".xr-var-dims:hover,\n",".xr-var-dtype:hover,\n",".xr-attrs dt:hover {\n","  overflow: visible;\n","  width: auto;\n","  z-index: 1;\n","}\n","\n",".xr-var-attrs,\n",".xr-var-data {\n","  display: none;\n","  background-color: var(--xr-background-color) !important;\n","  padding-bottom: 5px !important;\n","}\n","\n",".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",".xr-var-data-in:checked ~ .xr-var-data {\n","  display: block;\n","}\n","\n",".xr-var-data > table {\n","  float: right;\n","}\n","\n",".xr-var-name span,\n",".xr-var-data,\n",".xr-attrs {\n","  padding-left: 25px !important;\n","}\n","\n",".xr-attrs,\n",".xr-var-attrs,\n",".xr-var-data {\n","  grid-column: 1 / -1;\n","}\n","\n","dl.xr-attrs {\n","  padding: 0;\n","  margin: 0;\n","  display: grid;\n","  grid-template-columns: 125px auto;\n","}\n","\n",".xr-attrs dt,\n",".xr-attrs dd {\n","  padding: 0;\n","  margin: 0;\n","  float: left;\n","  padding-right: 10px;\n","  width: auto;\n","}\n","\n",".xr-attrs dt {\n","  font-weight: normal;\n","  grid-column: 1;\n","}\n","\n",".xr-attrs dt:hover span {\n","  display: inline-block;\n","  background: var(--xr-background-color);\n","  padding-right: 10px;\n","}\n","\n",".xr-attrs dd {\n","  grid-column: 2;\n","  white-space: pre-wrap;\n","  word-break: break-all;\n","}\n","\n",".xr-icon-database,\n",".xr-icon-file-text2 {\n","  display: inline-block;\n","  vertical-align: middle;\n","  width: 1em;\n","  height: 1.5em !important;\n","  stroke-width: 0;\n","  stroke: currentColor;\n","  fill: currentColor;\n","}\n",".xr-wrap{width:700px!important;} </style>"],"text/plain":["Inference data with groups:\n","\t> posterior\n","\t> sample_stats\n","\t> observed_data"]},"execution_count":44,"metadata":{},"output_type":"execute_result"}],"source":["trace"]},{"cell_type":"code","execution_count":45,"metadata":{"collapsed":false,"id":"AC1BB0B5DEF2457692D4559A81C7E88B","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[{"data":{"text/plain":["array([[<Axes: title={'center': 'mu_prior'}>,\n","        <Axes: title={'center': 'mu_prior'}>]], dtype=object)"]},"execution_count":45,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x200 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["az.plot_trace(trace)"]},{"cell_type":"code","execution_count":46,"metadata":{"collapsed":false,"id":"098AFCD3A3F942089AD001CFBA34F4E1","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"skip"},"tags":[],"trusted":true},"outputs":[],"source":["# 从 MCMC 采样结果中提取参数 mu 的后验分布样本\n","post_mu = pd.DataFrame({\"mu\": trace.posterior[\"mu_prior\"].values.reshape(-1)})"]},{"cell_type":"code","execution_count":63,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["后验分布的均值: 309.68992248062017\n","后验分布的标准差: 8.804509063256237\n"]}],"source":["#===========================================================================\n","#                            为了和真实的后验分布进行比较，计算真实的后验分布。\n","#===========================================================================\n","\n","\n","# 先验分布的均值和标准差\n","mu_prior = 300  # 先验均值\n","sigma_prior = 50  # 先验标准差\n","\n","# 观测数据的标准差 (已知)\n","sigma_obs = 20\n","\n","# 计算观测数据的数量和均值\n","n = len(observed_data)  \n","y_mean = np.mean(observed_data)  \n","\n","# 计算后验分布的均值和方差\n","posterior_mean = (sigma_obs**2 * mu_prior + n * sigma_prior**2 * y_mean) / (n * sigma_prior**2 + sigma_obs**2)\n","posterior_variance = (sigma_prior**2 * sigma_obs**2) / (n * sigma_prior**2 + sigma_obs**2)\n","posterior_std = np.sqrt(posterior_variance)\n","\n","print(f\"后验分布的均值: {posterior_mean}\")\n","print(f\"后验分布的标准差: {posterior_std}\")"]},{"cell_type":"code","execution_count":64,"metadata":{"collapsed":false,"id":"FE166A2DE62142C4AFE9425EE8EF6354","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[],"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1500x400 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["fig, (axs1, axs2) = plt.subplots(1, 2, figsize=(15, 4))\n","\n","sns.histplot(data=post_mu, \n","             x=\"mu\", \n","             bins=30,\n","             ax=axs1,\n","             edgecolor='#20699d', \n","             color=\"#6497b1\",\n","             alpha = 1)\n","\n","sns.kdeplot(data=post_mu,\n","             x=\"mu\",\n","             color='#6497b1',\n","             fill=True,\n","             alpha = 1,\n","             ax=axs2)\n","\n","\n","\n","# 计算真实的后验分布\n","x = np.linspace(200, 400, 10000)\n","y = st.norm.pdf(x, posterior_mean, posterior_std)\n","axs2.plot(x, y, color='black')\n","\n","sns.despine()\n"]},{"cell_type":"markdown","metadata":{"id":"7CE63A83CCDC48B694A365B9E85D3652","jupyter":{},"notebookId":"6536255793c31faf0a5a8dc8","runtime":{"execution_status":null,"is_visible":false,"status":"default"},"scrolled":false,"slideshow":{"slide_type":"slide"},"tags":[]},"source":["### 总结  \n","\n","在本节课中，我们深入探讨了 Metropolis-Hastings 算法 及其实际应用。通过 Normal-Normal 模型 的例子，我们演示了如何使用 MCMC 来近似后验分布。MCMC 是一种非常强大的工具，尤其在解析解无法直接求得时，提供了一种灵活且有效的计算方法。\n","\n","随着模型的复杂性增加，**后验分布可能变得难以解析，甚至无法获得。** 在这种情况下，近似方法是必要的。\n","\n","我们学习了两种用于逼近后验分布的技术：\n","1. **网格近似法：** 通过离散化参数空间，计算每个点的后验分布，再通过这些点近似整个后验。\n","2. **马尔科夫链蒙特卡罗（MCMC）：** 通过随机采样，生成符合后验分布的样本，逼近目标分布。\n","\n"]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"}},"nbformat":4,"nbformat_minor":2}
